Joint denoising and supersampling of graphics data

ABSTRACT

Joint denoising and supersampling of graphics data is described. An example of a graphics processor includes multiple processing resources, including a least a first processing resource including a pipeline to perform a supersampling operation; and the pipeline including circuitry to jointly perform denoising and supersampling of received ray tracing input data, the circuitry including first circuitry to receive input data associated with an input block for a neural network, second circuitry to perform operations associated with a feature extraction and kernel prediction network of the neural network, and third circuitry to perform operations associated with a filtering block of the neural network.

RELATED APPLICATIONS

This application is related to and claims priority to U.S. provisionalpatent application 63/276,257, filed Nov. 5, 2021.

FIELD

This disclosure relates generally to joint denoising and supersamplingof graphics data.

BACKGROUND OF THE DISCLOSURE

Temporal Anti-aliasing (TAA) is an anti-aliasing technique in which therenderer jitters the camera every frame to sample different coordinatesin screen space. The TAA stage accumulates these samples temporally toproduce a supersampled image. The previously accumulated frame is warpedusing renderer generated velocity/motion vectors to align it with thecurrent frame before accumulation. Although TAA is a widely usedtechnique to generate temporally stable anti-aliased image, the warpedsample history can be mismatched to the current pixel due toframe-to-frame changes in visibility and shading or errors in the motionvectors. This typically results in ghosting artifacts around movingobject boundary.

SuperSampling operation requires up-sampling to a higher resolution anddenoising, which commonly requires separate network operations.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example and notlimitation in the figures of the accompanying drawings in which likereferences indicate similar elements, and in which:

FIG. 1 is a block diagram illustrating a computer system configured toimplement one or more aspects of the embodiments described herein;

FIG. 2A-2D illustrate parallel processor components;

FIG. 3A-3C are block diagrams of graphics multiprocessors andmultiprocessor-based GPUs;

FIG. 4A-4F illustrate an exemplary architecture in which a plurality ofGPUs is communicatively coupled to a plurality of multi-core processors;

FIG. 5 illustrates a graphics processing pipeline;

FIG. 6 illustrates a machine learning software stack;

FIG. 7 illustrates a general-purpose graphics processing unit;

FIG. 8 illustrates a multi-GPU computing system;

FIG. 9A-9B illustrate layers of exemplary deep neural networks;

FIG. 10 illustrates an exemplary recurrent neural network;

FIG. 11 illustrates training and deployment of a deep neural network;

FIG. 12A is a block diagram illustrating distributed learning;

FIG. 12B is a block diagram illustrating a programmable networkinterface and data processing unit;

FIG. 13 illustrates an exemplary inferencing system on a chip (SOC)suitable for performing inferencing using a trained model;

FIG. 14 is a block diagram of a processing system;

FIG. 15A-15C illustrate computing systems and graphics processors;

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures;

FIG. 17 is a block diagram of a graphics processing engine of a graphicsprocessor;

FIG. 18A-18B illustrate thread execution logic including an array ofprocessing elements employed in a graphics processor core;

FIG. 19 illustrates an additional execution unit;

FIG. 20 is a block diagram illustrating a graphics processor instructionformats;

FIG. 21 is a block diagram of an additional graphics processorarchitecture;

FIG. 22A-22B illustrate a graphics processor command format and commandsequence;

FIG. 23 illustrates exemplary graphics software architecture for a dataprocessing system;

FIG. 24A is a block diagram illustrating an IP core development system;

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly;

FIG. 24C illustrates a package assembly that includes multiple units ofhardware logic chiplets connected to a substrate (e.g., base die);

FIG. 24D illustrates a package assembly including interchangeablechiplets;

FIG. 25 is a block diagram illustrating an exemplary system on a chipintegrated circuit;

FIG. 26A-26B are block diagrams illustrating exemplary graphicsprocessors for use within an SoC;

FIG. 27 is a block diagram of a data processing system, according to anembodiment;

FIG. 28A-28B illustrate a matrix operation performed by an instructionpipeline, according to an embodiment;

FIG. 29 illustrates a systolic array including multiplier and addercircuits organized in a pipelined fashion;

FIG. 30A-30B illustrates the use of a systolic array that can beconfigured to execute operations at an arbitrary systolic depth;

FIG. 31 illustrates a two-path matrix multiply accelerator in which eachpath has a depth of four stages;

FIG. 32 illustrates a four-path matrix multiply accelerator in whicheach path has a depth of two stages;

FIG. 33 illustrates a scalable sparse matrix multiply accelerator usingsystolic arrays with feedback inputs;

FIG. 34 shows a scalable sparse matrix multiply accelerator usingsystolic arrays with feedback inputs and outputs on each stage;

FIG. 35 illustrates a dual pipeline parallel systolic array for a matrixaccelerator, according to an embodiment;

FIG. 36 illustrates a stage pair for a channel of a systolic array;

FIG. 37 illustrates a systolic array including partial sum loopback andcircuitry to accelerate sparse matrix multiply;

FIG. 38A-38B illustrate matrix acceleration circuitry including codecsto enable the reading of sparse data in a compressed format;

FIG. 39 illustrates a conventional renderer with Temporal Anti-aliasing(TAA);

FIG. 40 illustrates a renderer that replaces the TAA stage with atemporally amortized supersampling stage;

FIG. 41 illustrate components of the neural network model, according toan embodiment;

FIG. 42 illustrates the input block of the neural network model,according to an embodiment;

FIG. 43A-43B illustrates output block variants for the neural networkmodel, according to embodiments;

FIG. 44 illustrates a method to perform temporally amortizedsupersampling;

FIG. 45 illustrates exemplary rendering performance comparisons formultiple rendering techniques described herein;

FIG. 46 is a block diagram of a computing device including a graphicsprocessor, according to an embodiment;

FIGS. 47A, 47B, and 47C are illustrations of a reconstruction pipeline,according to some embodiments;

FIG. 48 illustrates a joint neural denoiser and supersampler for agraphics reconstruction pipeline, according to some embodiments;

FIG. 49A is an illustration of joint denoising and supersampling in agraphics architecture, according to some embodiments;

FIG. 49B is an illustration of joint denoising and supersampling in analternative graphics architecture, according to some embodiments;

FIG. 50 is an illustration of a joint denoising and supersampling neuralnetwork, according to an embodiment;

FIG. 51 is an illustration of an input block for a neural networkutilized in joint denoising and supersampling, according to someembodiments; and

FIG. 52 is an illustration of a process for joint denoising andsupersampling utilizing a shared neural network, according to someembodiments.

DETAILED DESCRIPTION

A graphics processing unit (GPU) is communicatively coupled tohost/processor cores to accelerate, for example, graphics operations,machine-learning operations, pattern analysis operations, and/or variousgeneral-purpose GPU (GPGPU) functions. The GPU may be communicativelycoupled to the host processor/cores over a bus or another interconnect(e.g., a high-speed interconnect such as PCIe or NVLink). Alternatively,the GPU may be integrated on the same package or chip as the cores andcommunicatively coupled to the cores over an internal processorbus/interconnect (i.e., internal to the package or chip). Regardless ofthe manner in which the GPU is connected, the processor cores mayallocate work to the GPU in the form of sequences ofcommands/instructions contained in a work descriptor. The GPU then usesdedicated circuitry/logic for efficiently processing thesecommands/instructions.

Current parallel graphics data processing includes systems and methodsdeveloped to perform specific operations on graphics data such as, forexample, linear interpolation, tessellation, rasterization, texturemapping, depth testing, etc. Traditionally, graphics processors usedfixed function computational units to process graphics data. However,more recently, portions of graphics processors have been madeprogrammable, enabling such processors to support a wider variety ofoperations for processing vertex and fragment data.

To further increase performance, graphics processors typically implementprocessing techniques such as pipelining that attempt to process, inparallel, as much graphics data as possible throughout the differentparts of the graphics pipeline. Parallel graphics processors with singleinstruction, multiple thread (SIMT) architectures are designed tomaximize the amount of parallel processing in the graphics pipeline. Ina SIMT architecture, groups of parallel threads attempt to executeprogram instructions synchronously together as often as possible toincrease processing efficiency. A general overview of software andhardware for SIMT architectures can be found in Shane Cook, CUDAProgramming Chapter 3, pages 37-51 (2013).

Recent advances in ray tracing hardware bring real-time path tracinginto reach, and ray traced soft shadows, glossy reflections, and diffuseglobal illumination are now common features in games. However, raybudgets are still limited. This results in undersampling, whichmanifests as aliasing and noise. Existing technology addresses theissues of aliasing and noise separately. While temporal supersamplingmethods based on neural networks are used in modern games due to theirimproved robustness, neural network based denoising remains challengingbecause of its higher computational cost.

In some embodiments, temporal upsampling may be combined with TemporalAnti-aliasing (TAA) to upscale spatial resolution at the same time sothat frames are rendered at lower spatial resolution, which can saverendering time. Post-process stages after the temporal anti-aliasingupsampling can then run at the target display resolution. This operationallows the creation of sharper images than can be created usingspatial-only upscaling techniques and effectively reduces render timethan when rendering frames at a native display resolution.

In some embodiments, an apparatus, system, or process provides forperforming denoising and supersampling jointly using a singlemixed-precision convolutional neural network (CNN). An embodiment canachieve significantly better performance than is provided using multipleanalytical denoisers and a separate supersampling pass, without causingsignificant quality degradation.

In the following description, numerous specific details are set forth toprovide a more thorough understanding. However, it will be apparent toone of skill in the art that the embodiments described herein may bepracticed without one or more of these specific details. In otherinstances, well-known features have not been described to avoidobscuring the details of the present embodiments.

System Overview

FIG. 1 is a block diagram illustrating a computing system 100 configuredto implement one or more aspects of the embodiments described herein.The computing system 100 includes a processing subsystem 101 having oneor more processor(s) 102 and a system memory 104 communicating via aninterconnection path that may include a memory hub 105. The memory hub105 may be a separate component within a chipset component or may beintegrated within the one or more processor(s) 102. The memory hub 105couples with an I/O subsystem 111 via a communication link 106. The I/Osubsystem 111 includes an I/O hub 107 that can enable the computingsystem 100 to receive input from one or more input device(s) 108.Additionally, the I/O hub 107 can enable a display controller, which maybe included in the one or more processor(s) 102, to provide outputs toone or more display device(s) 110A. In one embodiment the one or moredisplay device(s) 110A coupled with the I/O hub 107 can include a local,internal, or embedded display device.

The processing subsystem 101, for example, includes one or more parallelprocessor(s) 112 coupled to memory hub 105 via a bus or othercommunication link 113. The communication link 113 may be one of anynumber of standards-based communication link technologies or protocols,such as, but not limited to PCI Express, or may be a vendor specificcommunications interface or communications fabric. The one or moreparallel processor(s) 112 may form a computationally focused parallel orvector processing system that can include a large number of processingcores and/or processing clusters, such as a many integrated core (MIC)processor. For example, the one or more parallel processor(s) 112 form agraphics processing subsystem that can output pixels to one of the oneor more display device(s) 110A coupled via the I/O hub 107. The one ormore parallel processor(s) 112 can also include a display controller anddisplay interface (not shown) to enable a direct connection to one ormore display device(s) 110B.

Within the I/O subsystem 111, a system storage unit 114 can connect tothe I/O hub 107 to provide a storage mechanism for the computing system100. An I/O switch 116 can be used to provide an interface mechanism toenable connections between the I/O hub 107 and other components, such asa network adapter 118 and/or wireless network adapter 119 that may beintegrated into the platform, and various other devices that can beadded via one or more add-in device(s) 120. The add-in device(s) 120 mayalso include, for example, one or more external graphics processordevices, graphics cards, and/or compute accelerators. The networkadapter 118 can be an Ethernet adapter or another wired network adapter.The wireless network adapter 119 can include one or more of a Wi-Fi,Bluetooth, near field communication (NFC), or other network device thatincludes one or more wireless radios.

The computing system 100 can include other components not explicitlyshown, including USB or other port connections, optical storage drives,video capture devices, and the like, which may also be connected to theI/O hub 107. Communication paths interconnecting the various componentsin FIG. 1 may be implemented using any suitable protocols, such as PCI(Peripheral Component Interconnect) based protocols (e.g., PCI-Express),or any other bus or point-to-point communication interfaces and/orprotocol(s), such as the NVLink high-speed interconnect, Compute ExpressLink™ (CXL™) (e.g., CXL.mem), Infinity Fabric (IF), Ethernet (IEEE802.3), remote direct memory access (RDMA), InfiniBand, Internet WideArea RDMA Protocol (iWARP), Transmission Control Protocol (TCP), UserDatagram Protocol (UDP), quick UDP Internet Connections (QUIC), RDMAover Converged Ethernet (RoCE), Intel QuickPath Interconnect (QPI),Intel Ultra Path Interconnect (UPI), Intel On-Chip System Fabric (IOSF),Omnipath, HyperTransport, Advanced Microcontroller Bus Architecture(AMBA) interconnect, OpenCAPI, Gen-Z, Cache Coherent Interconnect forAccelerators (CCIX), 3GPP Long Term Evolution (LTE) (4G), 3GPP 5G, andvariations thereof, or wired or wireless interconnect protocols known inthe art. In some examples, data can be copied or stored to virtualizedstorage nodes using a protocol such as non-volatile memory express(NVMe) over Fabrics (NVMe-oF) or NVMe.

The one or more parallel processor(s) 112 may incorporate circuitryoptimized for graphics and video processing, including, for example,video output circuitry, and constitutes a graphics processing unit(GPU). Alternatively or additionally, the one or more parallelprocessor(s) 112 can incorporate circuitry optimized for general purposeprocessing, while preserving the underlying computational architecture,described in greater detail herein. Components of the computing system100 may be integrated with one or more other system elements on a singleintegrated circuit. For example, the one or more parallel processor(s)112, memory hub 105, processor(s) 102, and I/O hub 107 can be integratedinto a system on chip (SoC) integrated circuit. Alternatively, thecomponents of the computing system 100 can be integrated into a singlepackage to form a system in package (SIP) configuration. In oneembodiment at least a portion of the components of the computing system100 can be integrated into a multi-chip module (MCM), which can beinterconnected with other multi-chip modules into a modular computingsystem.

It will be appreciated that the computing system 100 shown herein isillustrative and that variations and modifications are possible. Theconnection topology, including the number and arrangement of bridges,the number of processor(s) 102, and the number of parallel processor(s)112, may be modified as desired. For instance, system memory 104 can beconnected to the processor(s) 102 directly rather than through a bridge,while other devices communicate with system memory 104 via the memoryhub 105 and the processor(s) 102. In other alternative topologies, theparallel processor(s) 112 are connected to the I/O hub 107 or directlyto one of the one or more processor(s) 102, rather than to the memoryhub 105. In other embodiments, the I/O hub 107 and memory hub 105 may beintegrated into a single chip. It is also possible that two or more setsof processor(s) 102 are attached via multiple sockets, which can couplewith two or more instances of the parallel processor(s) 112.

Some of the particular components shown herein are optional and may notbe included in all implementations of the computing system 100. Forexample, any number of add-in cards or peripherals may be supported, orsome components may be eliminated. Furthermore, some architectures mayuse different terminology for components similar to those illustrated inFIG. 1 . For example, the memory hub 105 may be referred to as aNorthbridge in some architectures, while the I/O hub 107 may be referredto as a Southbridge.

FIG. 2A illustrates a parallel processor 200. The parallel processor 200may be a GPU, GPGPU or the like as described herein. The variouscomponents of the parallel processor 200 may be implemented using one ormore integrated circuit devices, such as programmable processors,application specific integrated circuits (ASICs), or field programmablegate arrays (FPGA). The illustrated parallel processor 200 may be one ormore of the parallel processor(s) 112 shown in FIG. 1 .

The parallel processor 200 includes a parallel processing unit 202. Theparallel processing unit includes an I/O unit 204 that enablescommunication with other devices, including other instances of theparallel processing unit 202. The I/O unit 204 may be directly connectedto other devices. For instance, the I/O unit 204 connects with otherdevices via the use of a hub or switch interface, such as memory hub105. The connections between the memory hub 105 and the I/O unit 204form a communication link 113. Within the parallel processing unit 202,the I/O unit 204 connects with a host interface 206 and a memorycrossbar 216, where the host interface 206 receives commands directed toperforming processing operations and the memory crossbar 216 receivescommands directed to performing memory operations.

When the host interface 206 receives a command buffer via the I/O unit204, the host interface 206 can direct work operations to perform thosecommands to a front end 208. In one embodiment the front end 208 coupleswith a scheduler 210, which is configured to distribute commands orother work items to a processing cluster array 212. The scheduler 210ensures that the processing cluster array 212 is properly configured andin a valid state before tasks are distributed to the processing clustersof the processing cluster array 212. The scheduler 210 may beimplemented via firmware logic executing on a microcontroller. Themicrocontroller implemented scheduler 210 is configurable to performcomplex scheduling and work distribution operations at coarse and finegranularity, enabling rapid preemption and context switching of threadsexecuting on the processing cluster array 212. Preferably, the hostsoftware can prove workloads for scheduling on the processing clusterarray 212 via one of multiple graphics processing doorbells. In otherexamples, polling for new workloads or interrupts can be used toidentify or indicate availability of work to perform. The workloads canthen be automatically distributed across the processing cluster array212 by the scheduler 210 logic within the scheduler microcontroller.

The processing cluster array 212 can include up to “N” processingclusters (e.g., cluster 214A, cluster 214B, through cluster 214N). Eachcluster 214A-214N of the processing cluster array 212 can execute alarge number of concurrent threads. The scheduler 210 can allocate workto the clusters 214A-214N of the processing cluster array 212 usingvarious scheduling and/or work distribution algorithms, which may varydepending on the workload arising for each type of program orcomputation. The scheduling can be handled dynamically by the scheduler210, or can be assisted in part by compiler logic during compilation ofprogram logic configured for execution by the processing cluster array212. Optionally, different clusters 214A-214N of the processing clusterarray 212 can be allocated for processing different types of programs orfor performing different types of computations.

The processing cluster array 212 can be configured to perform varioustypes of parallel processing operations. For example, the processingcluster array 212 is configured to perform general-purpose parallelcompute operations. For example, the processing cluster array 212 caninclude logic to execute processing tasks including filtering of videoand/or audio data, performing modeling operations, including physicsoperations, and performing data transformations.

The processing cluster array 212 is configured to perform parallelgraphics processing operations. In such embodiments in which theparallel processor 200 is configured to perform graphics processingoperations, the processing cluster array 212 can include additionallogic to support the execution of such graphics processing operations,including, but not limited to texture sampling logic to perform textureoperations, as well as tessellation logic and other vertex processinglogic. Additionally, the processing cluster array 212 can be configuredto execute graphics processing related shader programs such as, but notlimited to vertex shaders, tessellation shaders, geometry shaders, andpixel shaders. The parallel processing unit 202 can transfer data fromsystem memory via the I/O unit 204 for processing. During processing,the transferred data can be stored to on-chip memory (e.g., parallelprocessor memory 222) during processing, then written back to systemmemory.

In embodiments in which the parallel processing unit 202 is used toperform graphics processing, the scheduler 210 may be configured todivide the processing workload into approximately equal sized tasks, tobetter enable distribution of the graphics processing operations tomultiple clusters 214A-214N of the processing cluster array 212. In someof these embodiments, portions of the processing cluster array 212 canbe configured to perform different types of processing. For example, afirst portion may be configured to perform vertex shading and topologygeneration, a second portion may be configured to perform tessellationand geometry shading, and a third portion may be configured to performpixel shading or other screen space operations, to produce a renderedimage for display. Intermediate data produced by one or more of theclusters 214A-214N may be stored in buffers to allow the intermediatedata to be transmitted between clusters 214A-214N for furtherprocessing.

During operation, the processing cluster array 212 can receiveprocessing tasks to be executed via the scheduler 210, which receivescommands defining processing tasks from front end 208. For graphicsprocessing operations, processing tasks can include indices of data tobe processed, e.g., surface (patch) data, primitive data, vertex data,and/or pixel data, as well as state parameters and commands defining howthe data is to be processed (e.g., what program is to be executed). Thescheduler 210 may be configured to fetch the indices corresponding tothe tasks or may receive the indices from the front end 208. The frontend 208 can be configured to ensure the processing cluster array 212 isconfigured to a valid state before the workload specified by incomingcommand buffers (e.g., batch-buffers, push buffers, etc.) is initiated.

Each of the one or more instances of the parallel processing unit 202can couple with parallel processor memory 222. The parallel processormemory 222 can be accessed via the memory crossbar 216, which canreceive memory requests from the processing cluster array 212 as well asthe I/O unit 204. The memory crossbar 216 can access the parallelprocessor memory 222 via a memory interface 218. The memory interface218 can include multiple partition units (e.g., partition unit 220A,partition unit 220B, through partition unit 220N) that can each coupleto a portion (e.g., memory unit) of parallel processor memory 222. Thenumber of partition units 220A-220N may be configured to be equal to thenumber of memory units, such that a first partition unit 220A has acorresponding first memory unit 224A, a second partition unit 220B has acorresponding second memory unit 224B, and an Nth partition unit 220Nhas a corresponding Nth memory unit 224N. In other embodiments, thenumber of partition units 220A-220N may not be equal to the number ofmemory devices.

The memory units 224A-224N can include various types of memory devices,including dynamic random-access memory (DRAM) or graphics random accessmemory, such as synchronous graphics random access memory (SGRAM),including graphics double data rate (GDDR) memory. Optionally, thememory units 224A-224N may also include 3D stacked memory, including butnot limited to high bandwidth memory (HBM). Persons skilled in the artwill appreciate that the specific implementation of the memory units224A-224N can vary and can be selected from one of various conventionaldesigns. Render targets, such as frame buffers or texture maps may bestored across the memory units 224A-224N, allowing partition units220A-220N to write portions of each render target in parallel toefficiently use the available bandwidth of parallel processor memory222. In some embodiments, a local instance of the parallel processormemory 222 may be excluded in favor of a unified memory design thatutilizes system memory in conjunction with local cache memory.

Optionally, any one of the clusters 214A-214N of the processing clusterarray 212 has the ability to process data that will be written to any ofthe memory units 224A-224N within parallel processor memory 222. Thememory crossbar 216 can be configured to transfer the output of eachcluster 214A-214N to any partition unit 220A-220N or to another cluster214A-214N, which can perform additional processing operations on theoutput. Each cluster 214A-214N can communicate with the memory interface218 through the memory crossbar 216 to read from or write to variousexternal memory devices. In one of the embodiments with the memorycrossbar 216 the memory crossbar 216 has a connection to the memoryinterface 218 to communicate with the I/O unit 204, as well as aconnection to a local instance of the parallel processor memory 222,enabling the processing units within the different processing clusters214A-214N to communicate with system memory or other memory that is notlocal to the parallel processing unit 202. Generally, the memorycrossbar 216 may, for example, be able to use virtual channels toseparate traffic streams between the clusters 214A-214N and thepartition units 220A-220N.

While a single instance of the parallel processing unit 202 isillustrated within the parallel processor 200, any number of instancesof the parallel processing unit 202 can be included. For example,multiple instances of the parallel processing unit 202 can be providedon a single add-in card, or multiple add-in cards can be interconnected.For example, the parallel processor 200 can be an add-in device, such asadd-in device 120 of FIG. 1 , which may be a graphics card such as adiscrete graphics card that includes one or more GPUs, one or morememory devices, and device-to-device or network or fabric interfaces.The different instances of the parallel processing unit 202 can beconfigured to inter-operate even if the different instances havedifferent numbers of processing cores, different amounts of localparallel processor memory, and/or other configuration differences.Optionally, some instances of the parallel processing unit 202 caninclude higher precision floating point units relative to otherinstances. Systems incorporating one or more instances of the parallelprocessing unit 202 or the parallel processor 200 can be implemented ina variety of configurations and form factors, including but not limitedto desktop, laptop, or handheld personal computers, servers,workstations, game consoles, and/or embedded systems. An orchestratorcan form composite nodes for workload performance using one or more of:disaggregated processor resources, cache resources, memory resources,storage resources, and networking resources.

FIG. 2B is a block diagram of a partition unit 220. The partition unit220 may be an instance of one of the partition units 220A-220N of FIG.2A. As illustrated, the partition unit 220 includes an L2 cache 221, aframe buffer interface 225, and a ROP 226 (raster operations unit). TheL2 cache 221 is a read/write cache that is configured to perform loadand store operations received from the memory crossbar 216 and ROP 226.Read misses and urgent write-back requests are output by L2 cache 221 toframe buffer interface 225 for processing. Updates can also be sent tothe frame buffer via the frame buffer interface 225 for processing. Inone embodiment the frame buffer interface 225 interfaces with one of thememory units in parallel processor memory, such as the memory units224A-224N of FIG. 2A (e.g., within parallel processor memory 222). Thepartition unit 220 may additionally or alternatively also interface withone of the memory units in parallel processor memory via a memorycontroller (not shown).

In graphics applications, the ROP 226 is a processing unit that performsraster operations such as stencil, z test, blending, and the like. TheROP 226 then outputs processed graphics data that is stored in graphicsmemory. In some embodiments the ROP 226 includes or couples with a CODEC227 that includes compression logic to compress depth or color data thatis written to memory or the L2 cache 221 and decompress depth or colordata that is read from memory or the L2 cache 221. The compression logiccan be lossless compression logic that makes use of one or more ofmultiple compression algorithms. The type of compression that isperformed by the CODEC 227 can vary based on the statisticalcharacteristics of the data to be compressed. For example, in oneembodiment, delta color compression is performed on depth and color dataon a per-tile basis. In one embodiment the CODEC 227 includescompression and decompression logic that can compress and decompresscompute data associated with machine learning operations. The CODEC 227can, for example, compress sparse matrix data for sparse machinelearning operations. The CODEC 227 can also compress sparse matrix datathat is encoded in a sparse matrix format (e.g., coordinate listencoding (COO), compressed sparse row (CSR), compress sparse column(CSC), etc.) to generate compressed and encoded sparse matrix data. Thecompressed and encoded sparse matrix data can be decompressed and/ordecoded before being processed by processing elements or the processingelements can be configured to consume compressed, encoded, or compressedand encoded data for processing.

The ROP 226 may be included within each processing cluster (e.g.,cluster 214A-214N of FIG. 2A) instead of within the partition unit 220.In such embodiment, read and write requests for pixel data aretransmitted over the memory crossbar 216 instead of pixel fragment data.The processed graphics data may be displayed on a display device, suchas one of the one or more display device(s) 110A-110B of FIG. 1 , routedfor further processing by the processor(s) 102, or routed for furtherprocessing by one of the processing entities within the parallelprocessor 200 of FIG. 2A.

FIG. 2C is a block diagram of a processing cluster 214 within a parallelprocessing unit. For example, the processing cluster is an instance ofone of the processing clusters 214A-214N of FIG. 2A. The processingcluster 214 can be configured to execute many threads in parallel, wherethe term “thread” refers to an instance of a particular programexecuting on a particular set of input data. Optionally,single-instruction, multiple-data (SIMD) instruction issue techniquesmay be used to support parallel execution of a large number of threadswithout providing multiple independent instruction units. Alternatively,single-instruction, multiple-thread (SIMT) techniques may be used tosupport parallel execution of a large number of generally synchronizedthreads, using a common instruction unit configured to issueinstructions to a set of processing engines within each one of theprocessing clusters. Unlike a SIMD execution regime, where allprocessing engines typically execute identical instructions, SIMTexecution allows different threads to more readily follow divergentexecution paths through a given thread program. Persons skilled in theart will understand that a SIMD processing regime represents afunctional subset of a SIMT processing regime.

Operation of the processing cluster 214 can be controlled via a pipelinemanager 232 that distributes processing tasks to SIMT parallelprocessors. The pipeline manager 232 receives instructions from thescheduler 210 of FIG. 2A and manages execution of those instructions viaa graphics multiprocessor 234 and/or a texture unit 236. The illustratedgraphics multiprocessor 234 is an exemplary instance of a SIMT parallelprocessor. However, various types of SIMT parallel processors ofdiffering architectures may be included within the processing cluster214. One or more instances of the graphics multiprocessor 234 can beincluded within a processing cluster 214. The graphics multiprocessor234 can process data and a data crossbar 240 can be used to distributethe processed data to one of multiple possible destinations, includingother shader units. The pipeline manager 232 can facilitate thedistribution of processed data by specifying destinations for processeddata to be distributed via the data crossbar 240.

Each graphics multiprocessor 234 within the processing cluster 214 caninclude an identical set of functional execution logic (e.g., arithmeticlogic units, load-store units, etc.). The functional execution logic canbe configured in a pipelined manner in which new instructions can beissued before previous instructions are complete. The functionalexecution logic supports a variety of operations including integer andfloating-point arithmetic, comparison operations, Boolean operations,bit-shifting, and computation of various algebraic functions. The samefunctional-unit hardware could be leveraged to perform differentoperations and any combination of functional units may be present.

The instructions transmitted to the processing cluster 214 constitute athread. A set of threads executing across the set of parallel processingengines is a thread group. A thread group executes the same program ondifferent input data. Each thread within a thread group can be assignedto a different processing engine within a graphics multiprocessor 234. Athread group may include fewer threads than the number of processingengines within the graphics multiprocessor 234. When a thread groupincludes fewer threads than the number of processing engines, one ormore of the processing engines may be idle during cycles in which thatthread group is being processed. A thread group may also include morethreads than the number of processing engines within the graphicsmultiprocessor 234. When the thread group includes more threads than thenumber of processing engines within the graphics multiprocessor 234,processing can be performed over consecutive clock cycles. Optionally,multiple thread groups can be executed concurrently on the graphicsmultiprocessor 234.

The graphics multiprocessor 234 may include an internal cache memory toperform load and store operations. Optionally, the graphicsmultiprocessor 234 can forego an internal cache and use a cache memory(e.g., level 1 (L1) cache 248) within the processing cluster 214. Eachgraphics multiprocessor 234 also has access to level 2 (L2) cacheswithin the partition units (e.g., partition units 220A-220N of FIG. 2A)that are shared among all processing clusters 214 and may be used totransfer data between threads. The graphics multiprocessor 234 may alsoaccess off-chip global memory, which can include one or more of localparallel processor memory and/or system memory. Any memory external tothe parallel processing unit 202 may be used as global memory.Embodiments in which the processing cluster 214 includes multipleinstances of the graphics multiprocessor 234 can share commoninstructions and data, which may be stored in the L1 cache 248.

Each processing cluster 214 may include an MMU 245 (memory managementunit) that is configured to map virtual addresses into physicaladdresses. In other embodiments, one or more instances of the MMU 245may reside within the memory interface 218 of FIG. 2A. The MMU 245includes a set of page table entries (PTEs) used to map a virtualaddress to a physical address of a tile and optionally a cache lineindex. The MMU 245 may include address translation lookaside buffers(TLB) or caches that may reside within the graphics multiprocessor 234or the L1 cache or processing cluster 214. The physical address isprocessed to distribute surface data access locality to allow efficientrequest interleaving among partition units. The cache line index may beused to determine whether a request for a cache line is a hit or miss.

In graphics and computing applications, a processing cluster 214 may beconfigured such that each graphics multiprocessor 234 is coupled to atexture unit 236 for performing texture mapping operations, e.g.,determining texture sample positions, reading texture data, andfiltering the texture data. Texture data is read from an internaltexture L1 cache (not shown) or in some embodiments from the L1 cachewithin graphics multiprocessor 234 and is fetched from an L2 cache,local parallel processor memory, or system memory, as needed. Eachgraphics multiprocessor 234 outputs processed tasks to the data crossbar240 to provide the processed task to another processing cluster 214 forfurther processing or to store the processed task in an L2 cache, localparallel processor memory, or system memory via the memory crossbar 216.A preROP 242 (pre-raster operations unit) is configured to receive datafrom graphics multiprocessor 234, direct data to ROP units, which may belocated with partition units as described herein (e.g., partition units220A-220N of FIG. 2A). The preROP 242 unit can perform optimizations forcolor blending, organize pixel color data, and perform addresstranslations.

It will be appreciated that the core architecture described herein isillustrative and that variations and modifications are possible. Anynumber of processing units, e.g., graphics multiprocessor 234, textureunits 236, preROPs 242, etc., may be included within a processingcluster 214. Further, while only one processing cluster 214 is shown, aparallel processing unit as described herein may include any number ofinstances of the processing cluster 214. Optionally, each processingcluster 214 can be configured to operate independently of otherprocessing clusters 214 using separate and distinct processing units, L1caches, L2 caches, etc.

FIG. 2D shows an example of the graphics multiprocessor 234 in which thegraphics multiprocessor 234 couples with the pipeline manager 232 of theprocessing cluster 214. The graphics multiprocessor 234 has an executionpipeline including but not limited to an instruction cache 252, aninstruction unit 254, an address mapping unit 256, a register file 258,one or more general purpose graphics processing unit (GPGPU) cores 262,and one or more load/store units 266. The GPGPU cores 262 and load/storeunits 266 are coupled with cache memory 272 and shared memory 270 via amemory and cache interconnect 268. The graphics multiprocessor 234 mayadditionally include tensor and/or ray-tracing cores 263 that includehardware logic to accelerate matrix and/or ray-tracing operations.

The instruction cache 252 may receive a stream of instructions toexecute from the pipeline manager 232. The instructions are cached inthe instruction cache 252 and dispatched for execution by theinstruction unit 254. The instruction unit 254 can dispatch instructionsas thread groups (e.g., warps), with each thread of the thread groupassigned to a different execution unit within GPGPU core 262. Aninstruction can access any of a local, shared, or global address spaceby specifying an address within a unified address space. The addressmapping unit 256 can be used to translate addresses in the unifiedaddress space into a distinct memory address that can be accessed by theload/store units 266.

The register file 258 provides a set of registers for the functionalunits of the graphics multiprocessor 234. The register file 258 providestemporary storage for operands connected to the data paths of thefunctional units (e.g., GPGPU cores 262, load/store units 266) of thegraphics multiprocessor 234. The register file 258 may be dividedbetween each of the functional units such that each functional unit isallocated a dedicated portion of the register file 258. For example, theregister file 258 may be divided between the different warps beingexecuted by the graphics multiprocessor 234.

The GPGPU cores 262 can each include floating point units (FPUs) and/orinteger arithmetic logic units (ALUs) that are used to executeinstructions of the graphics multiprocessor 234. In someimplementations, the GPGPU cores 262 can include hardware logic that mayotherwise reside within the tensor and/or ray-tracing cores 263. TheGPGPU cores 262 can be similar in architecture or can differ inarchitecture. For example and in one embodiment, a first portion of theGPGPU cores 262 include a single precision FPU and an integer ALU whilea second portion of the GPGPU cores include a double precision FPU.Optionally, the FPUs can implement the IEEE 754-2008 standard forfloating point arithmetic or enable variable precision floating pointarithmetic. The graphics multiprocessor 234 can additionally include oneor more fixed function or special function units to perform specificfunctions such as copy rectangle or pixel blending operations. One ormore of the GPGPU cores can also include fixed or special functionlogic.

The GPGPU cores 262 may include SIMD logic capable of performing asingle instruction on multiple sets of data. Optionally, GPGPU cores 262can physically execute SIMD4, SIMD8, and SIMD16 instructions andlogically execute SIMD1, SIMD2, and SIMD32 instructions. The SIMDinstructions for the GPGPU cores can be generated at compile time by ashader compiler or automatically generated when executing programswritten and compiled for single program multiple data (SPMD) or SIMTarchitectures. Multiple threads of a program configured for the SIMTexecution model can be executed via a single SIMD instruction. Forexample and in one embodiment, eight SIMT threads that perform the sameor similar operations can be executed in parallel via a single SIMD8logic unit.

The memory and cache interconnect 268 is an interconnect network thatconnects each of the functional units of the graphics multiprocessor 234to the register file 258 and to the shared memory 270. For example, thememory and cache interconnect 268 is a crossbar interconnect that allowsthe load/store unit 266 to implement load and store operations betweenthe shared memory 270 and the register file 258. The register file 258can operate at the same frequency as the GPGPU cores 262, thus datatransfer between the GPGPU cores 262 and the register file 258 is verylow latency. The shared memory 270 can be used to enable communicationbetween threads that execute on the functional units within the graphicsmultiprocessor 234. The cache memory 272 can be used as a data cache forexample, to cache texture data communicated between the functional unitsand the texture unit 236. The shared memory 270 can also be used as aprogram managed cached. The shared memory 270 and the cache memory 272can couple with the data crossbar 240 to enable communication with othercomponents of the processing cluster. Threads executing on the GPGPUcores 262 can programmatically store data within the shared memory inaddition to the automatically cached data that is stored within thecache memory 272.

FIG. 3A-3C illustrate additional graphics multiprocessors, according toembodiments. FIG. 3A-3B illustrate graphics multiprocessors 325, 350,which are related to the graphics multiprocessor 234 of FIG. 2C and maybe used in place of one of those. Therefore, the disclosure of anyfeatures in combination with the graphics multiprocessor 234 herein alsodiscloses a corresponding combination with the graphicsmultiprocessor(s) 325, 350, but is not limited to such. FIG. 3Cillustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N, which correspond to the graphics multiprocessors 325,350. The illustrated graphics multiprocessors 325, 350 and themulti-core groups 365A-365N can be streaming multiprocessors (SM)capable of simultaneous execution of a large number of executionthreads.

The graphics multiprocessor 325 of FIG. 3A includes multiple additionalinstances of execution resource units relative to the graphicsmultiprocessor 234 of FIG. 2D. For example, the graphics multiprocessor325 can include multiple instances of the instruction unit 332A-332B,register file 334A-334B, and texture unit(s) 344A-344B. The graphicsmultiprocessor 325 also includes multiple sets of graphics or computeexecution units (e.g., GPGPU core 336A-336B, tensor core 337A-337B,ray-tracing core 338A-338B) and multiple sets of load/store units340A-340B. The execution resource units have a common instruction cache330, texture and/or data cache memory 342, and shared memory 346.

The various components can communicate via an interconnect fabric 327.The interconnect fabric 327 may include one or more crossbar switches toenable communication between the various components of the graphicsmultiprocessor 325. The interconnect fabric 327 may be a separate,high-speed network fabric layer upon which each component of thegraphics multiprocessor 325 is stacked. The components of the graphicsmultiprocessor 325 communicate with remote components via theinterconnect fabric 327. For example, the cores 336A-336B, 337A-337B,and 338A-338B can each communicate with shared memory 346 via theinterconnect fabric 327. The interconnect fabric 327 can arbitratecommunication within the graphics multiprocessor 325 to ensure a fairbandwidth allocation between components.

The graphics multiprocessor 350 of FIG. 3B includes multiple sets ofexecution resources 356A-356D, where each set of execution resourceincludes multiple instruction units, register files, GPGPU cores, andload store units, as illustrated in FIG. 2D and FIG. 3A. The executionresources 356A-356D can work in concert with texture unit(s) 360A-360Dfor texture operations, while sharing an instruction cache 354, andshared memory 353. For example, the execution resources 356A-356D canshare an instruction cache 354 and shared memory 353, as well asmultiple instances of a texture and/or data cache memory 358A-358B. Thevarious components can communicate via an interconnect fabric 352similar to the interconnect fabric 327 of FIG. 3A.

Persons skilled in the art will understand that the architecturedescribed in FIGS. 1, 2A-2D, and 3A-3B are descriptive and not limitingas to the scope of the present embodiments. Thus, the techniquesdescribed herein may be implemented on any properly configuredprocessing unit, including, without limitation, one or more mobileapplication processors, one or more desktop or server central processingunits (CPUs) including multi-core CPUs, one or more parallel processingunits, such as the parallel processing unit 202 of FIG. 2A, as well asone or more graphics processors or special purpose processing units,without departure from the scope of the embodiments described herein.

The parallel processor or GPGPU as described herein may becommunicatively coupled to host/processor cores to accelerate graphicsoperations, machine-learning operations, pattern analysis operations,and various general-purpose GPU (GPGPU) functions. The GPU may becommunicatively coupled to the host processor/cores over a bus or otherinterconnect (e.g., a high-speed interconnect such as PCIe, NVLink, orother known protocols, standardized protocols, or proprietaryprotocols). In other embodiments, the GPU may be integrated on the samepackage or chip as the cores and communicatively coupled to the coresover an internal processor bus/interconnect (i.e., internal to thepackage or chip). Regardless of the manner in which the GPU isconnected, the processor cores may allocate work to the GPU in the formof sequences of commands/instructions contained in a work descriptor.The GPU then uses dedicated circuitry/logic for efficiently processingthese commands/instructions.

FIG. 3C illustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N. While the details of only a single multi-core group365A are provided, it will be appreciated that the other multi-coregroups 365B-365N may be equipped with the same or similar sets ofgraphics processing resources. Details described with respect to themulti-core groups 365A-365N may also apply to any graphicsmultiprocessor 234, 325, 350 described herein.

As illustrated, a multi-core group 365A may include a set of graphicscores 370, a set of tensor cores 371, and a set of ray tracing cores372. A scheduler/dispatcher 368 schedules and dispatches the graphicsthreads for execution on the various cores 370, 371, 372. A set ofregister files 369 store operand values used by the cores 370, 371, 372when executing the graphics threads. These may include, for example,integer registers for storing integer values, floating point registersfor storing floating point values, vector registers for storing packeddata elements (integer and/or floating-point data elements) and tileregisters for storing tensor/matrix values. The tile registers may beimplemented as combined sets of vector registers.

One or more combined level 1 (L1) caches and shared memory units 373store graphics data such as texture data, vertex data, pixel data, raydata, bounding volume data, etc., locally within each multi-core group365A. One or more texture units 374 can also be used to performtexturing operations, such as texture mapping and sampling. A Level 2(L2) cache 375 shared by all or a subset of the multi-core groups365A-365N stores graphics data and/or instructions for multipleconcurrent graphics threads. As illustrated, the L2 cache 375 may beshared across a plurality of multi-core groups 365A-365N. One or morememory controllers 367 couple the GPU 380 to a memory 366 which may be asystem memory (e.g., DRAM) and/or a dedicated graphics memory (e.g.,GDDR6 memory).

Input/output (I/O) circuitry 363 couples the GPU 380 to one or more I/Odevices 362 such as digital signal processors (DSPs), networkcontrollers, or user input devices. An on-chip interconnect may be usedto couple the I/O devices 362 to the GPU 380 and memory 366. One or moreI/O memory management units (IOMMUs) 364 of the I/O circuitry 363 couplethe I/O devices 362 directly to the system memory 366. Optionally, theIOMMU 364 manages multiple sets of page tables to map virtual addressesto physical addresses in system memory 366. The I/O devices 362, CPU(s)361, and GPU(s) 380 may then share the same virtual address space.

In one implementation of the IOMMU 364, the IOMMU 364 supportsvirtualization. In this case, it may manage a first set of page tablesto map guest/graphics virtual addresses to guest/graphics physicaladdresses and a second set of page tables to map the guest/graphicsphysical addresses to system/host physical addresses (e.g., withinsystem memory 366). The base addresses of each of the first and secondsets of page tables may be stored in control registers and swapped outon a context switch (e.g., so that the new context is provided withaccess to the relevant set of page tables). While not illustrated inFIG. 3C, each of the cores 370, 371, 372 and/or multi-core groups365A-365N may include translation lookaside buffers (TLBs) to cacheguest virtual to guest physical translations, guest physical to hostphysical translations, and guest virtual to host physical translations.

The CPU(s) 361, GPUs 380, and I/O devices 362 may be integrated on asingle semiconductor chip and/or chip package. The illustrated memory366 may be integrated on the same chip or may be coupled to the memorycontrollers 367 via an off-chip interface. In one implementation, thememory 366 comprises GDDR6 memory which shares the same virtual addressspace as other physical system-level memories, although the underlyingprinciples described herein are not limited to this specificimplementation.

The tensor cores 371 may include a plurality of execution unitsspecifically designed to perform matrix operations, which are thefundamental compute operation used to perform deep learning operations.For example, simultaneous matrix multiplication operations may be usedfor neural network training and inferencing. The tensor cores 371 mayperform matrix processing using a variety of operand precisionsincluding single precision floating-point (e.g., 32 bits),half-precision floating point (e.g., 16 bits), integer words (16 bits),bytes (8 bits), and half-bytes (4 bits). For example, a neural networkimplementation extracts features of each rendered scene, potentiallycombining details from multiple frames, to construct a high-qualityfinal image.

In deep learning implementations, parallel matrix multiplication workmay be scheduled for execution on the tensor cores 371. The training ofneural networks, in particular, requires a significant number of matrixdot product operations. In order to process an inner-product formulationof an N×N×N matrix multiply, the tensor cores 371 may include at least Ndot-product processing elements. Before the matrix multiply begins, oneentire matrix is loaded into tile registers and at least one column of asecond matrix is loaded each cycle for N cycles. Each cycle, there are Ndot products that are processed.

Matrix elements may be stored at different precisions depending on theparticular implementation, including 16-bit words, 8-bit bytes (e.g.,INT8) and 4-bit half-bytes (e.g., INT4). Different precision modes maybe specified for the tensor cores 371 to ensure that the most efficientprecision is used for different workloads (e.g., such as inferencingworkloads which can tolerate quantization to bytes and half-bytes).Supported formats additionally include 64-bit floating point (FP64) andnon-IEEE floating point formats such as the bfloat16 format (e.g., Brainfloating point), a 16-bit floating point format with one sign bit, eightexponent bits, and eight significand bits, of which seven are explicitlystored. One embodiment includes support for a reduced precisiontensor-float format (TF32), which has the range of FP32 (8-bits) withthe precision of FP16 (10-bits). Reduced precision TF32 operations canbe performed on FP32 inputs and produce FP32 outputs at higherperformance relative to FP32 and increased precision relative to FP16.

In one embodiment the tensor cores 371 support a sparse mode ofoperation for matrices in which the vast majority of values are zero.The tensor cores 371 include support for sparse input matrices that areencoded in a sparse matrix representation (e.g., coordinate listencoding (COO), compressed sparse row (CSR), compress sparse column(CSC), etc.). The tensor cores 371 also include support for compressedsparse matrix representations in the event that the sparse matrixrepresentation may be further compressed. Compressed, encoded, and/orcompressed and encoded matrix data, along with associated compressionand/or encoding metadata, can be read by the tensor cores 371 and thenon-zero values can be extracted. For example, for a given input matrixA, a non-zero value can be loaded from the compressed and/or encodedrepresentation of at least a portion of matrix A. Based on the locationin matrix A for the non-zero value, which may be determined from indexor coordinate metadata associated with the non-zero value, acorresponding value in input matrix B may be loaded. Depending on theoperation to be performed (e.g., multiply), the load of the value frominput matrix B may be bypassed if the corresponding value is a zerovalue. In one embodiment, the pairings of values for certain operations,such as multiply operations, may be pre-scanned by scheduler logic andonly operations between non-zero inputs are scheduled. Depending on thedimensions of matrix A and matrix B and the operation to be performed,output matrix C may be dense or sparse. Where output matrix C is sparseand depending on the configuration of the tensor cores 371, outputmatrix C may be output in a compressed format, a sparse encoding, or acompressed sparse encoding.

The ray tracing cores 372 may accelerate ray tracing operations for bothreal-time ray tracing and non-real-time ray tracing implementations. Inparticular, the ray tracing cores 372 may include raytraversal/intersection circuitry for performing ray traversal usingbounding volume hierarchies (BVHs) and identifying intersections betweenrays and primitives enclosed within the BVH volumes. The ray tracingcores 372 may also include circuitry for performing depth testing andculling (e.g., using a Z buffer or similar arrangement). In oneimplementation, the ray tracing cores 372 perform traversal andintersection operations in concert with the image denoising techniquesdescribed herein, at least a portion of which may be executed on thetensor cores 371. For example, the tensor cores 371 may implement a deeplearning neural network to perform denoising of frames generated by theray tracing cores 372. However, the CPU(s) 361, graphics cores 370,and/or ray tracing cores 372 may also implement all or a portion of thedenoising and/or deep learning algorithms.

In addition, as described above, a distributed approach to denoising maybe employed in which the GPU 380 is in a computing device coupled toother computing devices over a network or high-speed interconnect. Inthis distributed approach, the interconnected computing devices mayshare neural network learning/training data to improve the speed withwhich the overall system learns to perform denoising for different typesof image frames and/or different graphics applications.

The ray tracing cores 372 may process all BVH traversal and/orray-primitive intersections, saving the graphics cores 370 from beingoverloaded with thousands of instructions per ray. For example, each raytracing core 372 includes a first set of specialized circuitry forperforming bounding box tests (e.g., for traversal operations) and/or asecond set of specialized circuitry for performing the ray-triangleintersection tests (e.g., intersecting rays which have been traversed).Thus, for example, the multi-core group 365A can simply launch a rayprobe, and the ray tracing cores 372 independently perform ray traversaland intersection and return hit data (e.g., a hit, no hit, multiplehits, etc.) to the thread context. The other cores 370, 371 are freed toperform other graphics or compute work while the ray tracing cores 372perform the traversal and intersection operations.

Optionally, each ray tracing core 372 may include a traversal unit toperform BVH testing operations and/or an intersection unit whichperforms ray-primitive intersection tests. The intersection unitgenerates a “hit”, “no hit”, or “multiple hit” response, which itprovides to the appropriate thread. During the traversal andintersection operations, the execution resources of the other cores(e.g., graphics cores 370 and tensor cores 371) are freed to performother forms of graphics work.

In one optional embodiment described below, a hybrid rasterization/raytracing approach is used in which work is distributed between thegraphics cores 370 and ray tracing cores 372.

The ray tracing cores 372 (and/or other cores 370, 371) may includehardware support for a ray tracing instruction set such as Microsoft'sDirectX Ray Tracing (DXR) which includes a DispatchRays command, as wellas ray-generation, closest-hit, any-hit, and miss shaders, which enablethe assignment of unique sets of shaders and textures for each object.Another ray tracing platform which may be supported by the ray tracingcores 372, graphics cores 370 and tensor cores 371 is Vulkan 1.1.85.Note, however, that the underlying principles described herein are notlimited to any particular ray tracing ISA.

In general, the various cores 372, 371, 370 may support a ray tracinginstruction set that includes instructions/functions for one or more ofray generation, closest hit, any hit, ray-primitive intersection,per-primitive and hierarchical bounding box construction, miss, visit,and exceptions. More specifically, a preferred embodiment includes raytracing instructions to perform one or more of the following functions:

Ray Generation—Ray generation instructions may be executed for eachpixel, sample, or other user-defined work assignment.

Closest Hit—A closest hit instruction may be executed to locate theclosest intersection point of a ray with primitives within a scene.

Any Hit—An any hit instruction identifies multiple intersections betweena ray and primitives within a scene, potentially to identify a newclosest intersection point.

Intersection—An intersection instruction performs a ray-primitiveintersection test and outputs a result.

Per-primitive Bounding box Construction—This instruction builds abounding box around a given primitive or group of primitives (e.g., whenbuilding a new BVH or other acceleration data structure).

Miss—Indicates that a ray misses all geometry within a scene, orspecified region of a scene.

Visit—Indicates the children volumes a ray will traverse.

Exceptions—Includes various types of exception handlers (e.g., invokedfor various error conditions).

In one embodiment the ray tracing cores 372 may be adapted to accelerategeneral-purpose compute operations that can be accelerated usingcomputational techniques that are analogous to ray intersection tests. Acompute framework can be provided that enables shader programs to becompiled into low level instructions and/or primitives that performgeneral-purpose compute operations via the ray tracing cores. Exemplarycomputational problems that can benefit from compute operationsperformed on the ray tracing cores 372 include computations involvingbeam, wave, ray, or particle propagation within a coordinate space.Interactions associated with that propagation can be computed relativeto a geometry or mesh within the coordinate space. For example,computations associated with electromagnetic signal propagation throughan environment can be accelerated via the use of instructions orprimitives that are executed via the ray tracing cores. Diffraction andreflection of the signals by objects in the environment can be computedas direct ray-tracing analogies.

Ray tracing cores 372 can also be used to perform computations that arenot directly analogous to ray tracing. For example, mesh projection,mesh refinement, and volume sampling computations can be acceleratedusing the ray tracing cores 372. Generic coordinate space calculations,such as nearest neighbor calculations can also be performed. Forexample, the set of points near a given point can be discovered bydefining a bounding box in the coordinate space around the point. BVHand ray probe logic within the ray tracing cores 372 can then be used todetermine the set of point intersections within the bounding box. Theintersections constitute the origin point and the nearest neighbors tothat origin point. Computations that are performed using the ray tracingcores 372 can be performed in parallel with computations performed onthe graphics cores 372 and tensor cores 371. A shader compiler can beconfigured to compile a compute shader or other general-purpose graphicsprocessing program into low level primitives that can be parallelizedacross the graphics cores 370, tensor cores 371, and ray tracing cores372.

Techniques for GPU to Host Processor Interconnection

FIG. 4A illustrates an exemplary architecture in which a plurality ofGPUs 410-413, e.g. such as the parallel processors 200 shown in FIG. 2A,are communicatively coupled to a plurality of multi-core processors405-406 over high-speed links 440A-440D (e.g., buses, point-to-pointinterconnects, etc.). The high-speed links 440A-440D may support acommunication throughput of 4 GB/s, 30 GB/s, 80 GB/s or higher,depending on the implementation. Various interconnect protocols may beused including, but not limited to, PCIe 4.0 or 5.0 and NVLink 2.0.However, the underlying principles described herein are not limited toany particular communication protocol or throughput.

Two or more of the GPUs 410-413 may be interconnected over high-speedlinks 442A-442B, which may be implemented using the same or differentprotocols/links than those used for high-speed links 440A-440D.Similarly, two or more of the multi-core processors 405-406 may beconnected over high-speed link 443 which may be symmetricmulti-processor (SMP) buses operating at 20 GB/s, 30 GB/s, 120 GB/s orlower or higher speeds. Alternatively, all communication between thevarious system components shown in FIG. 4A may be accomplished using thesame protocols/links (e.g., over a common interconnection fabric). Asmentioned, however, the underlying principles described herein are notlimited to any particular type of interconnect technology.

Each multi-core processor 405-406 may be communicatively coupled to aprocessor memory 401-402, via memory interconnects 430A-430B,respectively, and each GPU 410-413 is communicatively coupled to GPUmemory 420-423 over GPU memory interconnects 450A-450D, respectively.The memory interconnects 430A-430B and 450A-450D may utilize the same ordifferent memory access technologies. By way of example, and notlimitation, the processor memories 401-402 and GPU memories 420-423 maybe volatile memories such as dynamic random-access memories (DRAMs)(including stacked DRAMs), Graphics DDR SDRAM (GDDR) (e.g., GDDR5,GDDR6), or High Bandwidth Memory (HBM) and/or may be non-volatilememories such as 3D XPoint/Optane or Nano-Ram. For example, some portionof the memories may be volatile memory and another portion may benon-volatile memory (e.g., using a two-level memory (2LM) hierarchy). Amemory subsystem as described herein may be compatible with a number ofmemory technologies, such as Double Data Rate versions released by JEDEC(Joint Electronic Device Engineering Council).

As described below, although the various processors 405-406 and GPUs410-413 may be physically coupled to a particular memory 401-402,420-423, respectively, a unified memory architecture may be implementedin which the same virtual system address space (also referred to as the“effective address” space) is distributed among all of the variousphysical memories. For example, processor memories 401-402 may eachcomprise 64 GB of the system memory address space and GPU memories420-423 may each comprise 32 GB of the system memory address space(resulting in a total of 256 GB addressable memory in this example).

FIG. 4B illustrates additional optional details for an interconnectionbetween a multi-core processor 407 and a graphics acceleration module446. The graphics acceleration module 446 may include one or more GPUchips integrated on a line card which is coupled to the processor 407via the high-speed link 440. Alternatively, the graphics accelerationmodule 446 may be integrated on the same package or chip as theprocessor 407.

The illustrated processor 407 includes a plurality of cores 460A-460D,each with a translation lookaside buffer 461A-461D and one or morecaches 462A-462D. The cores may include various other components forexecuting instructions and processing data which are not illustrated toavoid obscuring the underlying principles of the components describedherein (e.g., instruction fetch units, branch prediction units,decoders, execution units, reorder buffers, etc.). The caches 462A-462Dmay comprise level 1 (L1) and level 2 (L2) caches. In addition, one ormore shared caches 456 may be included in the caching hierarchy andshared by sets of the cores 460A-460D. For example, one embodiment ofthe processor 407 includes 24 cores, each with its own L1 cache, twelveshared L2 caches, and twelve shared L3 caches. In this embodiment, oneof the L2 and L3 caches are shared by two adjacent cores. The processor407 and the graphics accelerator integration module 446 connect withsystem memory 441, which may include processor memories 401-402.

Coherency is maintained for data and instructions stored in the variouscaches 462A-462D, 456 and system memory 441 via inter-core communicationover a coherence bus 464. For example, each cache may have cachecoherency logic/circuitry associated therewith to communicate to overthe coherence bus 464 in response to detected reads or writes toparticular cache lines. In one implementation, a cache snooping protocolis implemented over the coherence bus 464 to snoop cache accesses. Cachesnooping/coherency techniques are well understood by those of skill inthe art and will not be described in detail here to avoid obscuring theunderlying principles described herein.

A proxy circuit 425 may be provided that communicatively couples thegraphics acceleration module 446 to the coherence bus 464, allowing thegraphics acceleration module 446 to participate in the cache coherenceprotocol as a peer of the cores. In particular, an interface 435provides connectivity to the proxy circuit 425 over high-speed link 440(e.g., a PCIe bus, NVLink, etc.) and an interface 437 connects thegraphics acceleration module 446 to the high-speed link 440.

In one implementation, an accelerator integration circuit 436 providescache management, memory access, context management, and interruptmanagement services on behalf of a plurality of graphics processingengines 431, 432, N of the graphics acceleration module 446. Thegraphics processing engines 431, 432, N may each comprise a separategraphics processing unit (GPU). Alternatively, the graphics processingengines 431, 432, N may comprise different types of graphics processingengines within a GPU such as graphics execution units, media processingengines (e.g., video encoders/decoders), samplers, and blit engines. Inother words, the graphics acceleration module may be a GPU with aplurality of graphics processing engines 431-432, N or the graphicsprocessing engines 431-432, N may be individual GPUs integrated on acommon package, line card, or chip.

The accelerator integration circuit 436 may include a memory managementunit (MMU) 439 for performing various memory management functions suchas virtual-to-physical memory translations (also referred to aseffective-to-real memory translations) and memory access protocols foraccessing system memory 441. The MMU 439 may also include a translationlookaside buffer (TLB) (not shown) for caching the virtual/effective tophysical/real address translations. In one implementation, a cache 438stores commands and data for efficient access by the graphics processingengines 431, 432, N. The data stored in cache 438 and graphics memories433-434, M may be kept coherent with the core caches 462A-462D, 456 andsystem memory 441. As mentioned, this may be accomplished via proxycircuit 425 which takes part in the cache coherency mechanism on behalfof cache 438 and memories 433-434, M (e.g., sending updates to the cache438 related to modifications/accesses of cache lines on processor caches462A-462D, 456 and receiving updates from the cache 438).

A set of registers 445 store context data for threads executed by thegraphics processing engines 431-432, N and a context management circuit448 manages the thread contexts. For example, the context managementcircuit 448 may perform save and restore operations to save and restorecontexts of the various threads during contexts switches (e.g., where afirst thread is saved and a second thread is restored so that the secondthread can be execute by a graphics processing engine). For example, ona context switch, the context management circuit 448 may store currentregister values to a designated region in memory (e.g., identified by acontext pointer). It may then restore the register values when returningto the context. An interrupt management circuit 447, for example, mayreceive and processes interrupts received from system devices.

In one implementation, virtual/effective addresses from a graphicsprocessing engine 431 are translated to real/physical addresses insystem memory 441 by the MMU 439. Optionally, the acceleratorintegration circuit 436 supports multiple (e.g., 4, 8, 16) graphicsaccelerator modules 446 and/or other accelerator devices. The graphicsaccelerator module 446 may be dedicated to a single application executedon the processor 407 or may be shared between multiple applications.Optionally, a virtualized graphics execution environment is provided inwhich the resources of the graphics processing engines 431-432, N areshared with multiple applications, virtual machines (VMs), orcontainers. The resources may be subdivided into “slices” which areallocated to different VMs and/or applications based on the processingrequirements and priorities associated with the VMs and/or applications.VMs and containers can be used interchangeably herein.

A virtual machine (VM) can be software that runs an operating system andone or more applications. A VM can be defined by specification,configuration files, virtual disk file, non-volatile random-accessmemory (NVRAM) setting file, and the log file and is backed by thephysical resources of a host computing platform. A VM can include anoperating system (OS) or application environment that is installed onsoftware, which imitates dedicated hardware. The end user has the sameexperience on a virtual machine as they would have on dedicatedhardware. Specialized software, called a hypervisor, emulates the PCclient or server's CPU, memory, hard disk, network and other hardwareresources completely, enabling virtual machines to share the resources.The hypervisor can emulate multiple virtual hardware platforms that areisolated from each other, allowing virtual machines to run Linux®,Windows® Server, VMware ESXi, and other operating systems on the sameunderlying physical host.

A container can be a software package of applications, configurationsand dependencies so the applications run reliably on one computingenvironment to another. Containers can share an operating systeminstalled on the server platform and run as isolated processes. Acontainer can be a software package that contains everything thesoftware needs to run such as system tools, libraries, and settings.Containers are not installed like traditional software programs, whichallows them to be isolated from the other software and the operatingsystem itself. The isolated nature of containers provides severalbenefits. First, the software in a container will run the same indifferent environments. For example, a container that includes PHP andMySQL can run identically on both a Linux® computer and a Windows®machine. Second, containers provide added security since the softwarewill not affect the host operating system. While an installedapplication may alter system settings and modify resources, such as theWindows registry, a container can only modify settings within thecontainer.

Thus, the accelerator integration circuit 436 acts as a bridge to thesystem for the graphics acceleration module 446 and provides addresstranslation and system memory cache services. In one embodiment, tofacilitate the bridging functionality, the accelerator integrationcircuit 436 may also include shared I/O 497 (e.g., PCIe, USB, or others)and hardware to enable system control of voltage, clocking, performance,thermals, and security. The shared I/O 497 may utilize separate physicalconnections or may traverse the high-speed link 440. In addition, theaccelerator integration circuit 436 may provide virtualizationfacilities for the host processor to manage virtualization of thegraphics processing engines, interrupts, and memory management.

Because hardware resources of the graphics processing engines 431-432, Nare mapped explicitly to the real address space seen by the hostprocessor 407, any host processor can address these resources directlyusing an effective address value. One optional function of theaccelerator integration circuit 436 is the physical separation of thegraphics processing engines 431-432, N so that they appear to the systemas independent units.

One or more graphics memories 433-434, M may be coupled to each of thegraphics processing engines 431-432, N, respectively. The graphicsmemories 433-434, M store instructions and data being processed by eachof the graphics processing engines 431-432, N. The graphics memories433-434, M may be volatile memories such as DRAMs (including stackedDRAMs), GDDR memory (e.g., GDDR5, GDDR6), or HBM, and/or may benon-volatile memories such as 3D XPoint/Optane, Samsung Z-NAND, orNano-Ram.

To reduce data traffic over the high-speed link 440, biasing techniquesmay be used to ensure that the data stored in graphics memories 433-434,M is data which will be used most frequently by the graphics processingengines 431-432, N and preferably not used by the cores 460A-460D (atleast not frequently). Similarly, the biasing mechanism attempts to keepdata needed by the cores (and preferably not the graphics processingengines 431-432, N) within the caches 462A-462D, 456 of the cores andsystem memory 441.

According to a variant shown in FIG. 4C the accelerator integrationcircuit 436 is integrated within the processor 407. The graphicsprocessing engines 431-432, N communicate directly over the high-speedlink 440 to the accelerator integration circuit 436 via interface 437and interface 435 (which, again, may be utilize any form of bus orinterface protocol). The accelerator integration circuit 436 may performthe same operations as those described with respect to FIG. 4B, butpotentially at a higher throughput given its close proximity to thecoherence bus 464 and caches 462A-462D, 456.

The embodiments described may support different programming modelsincluding a dedicated-process programming model (no graphicsacceleration module virtualization) and shared programming models (withvirtualization). The latter may include programming models which arecontrolled by the accelerator integration circuit 436 and programmingmodels which are controlled by the graphics acceleration module 446.

In the embodiments of the dedicated process model, graphics processingengines 431, 432, . . . N may be dedicated to a single application orprocess under a single operating system. The single application canfunnel other application requests to the graphics engines 431, 432, . .. N, providing virtualization within a VM/partition.

In the dedicated-process programming models, the graphics processingengines 431,432, N, may be shared by multiple VM/application partitions.The shared models require a system hypervisor to virtualize the graphicsprocessing engines 431-432, N to allow access by each operating system.For single-partition systems without a hypervisor, the graphicsprocessing engines 431-432, N are owned by the operating system. In bothcases, the operating system can virtualize the graphics processingengines 431-432, N to provide access to each process or application.

For the shared programming model, the graphics acceleration module 446or an individual graphics processing engine 431-432, N selects a processelement using a process handle. The process elements may be stored insystem memory 441 and be addressable using the effective address to realaddress translation techniques described herein. The process handle maybe an implementation-specific value provided to the host process whenregistering its context with the graphics processing engine 431-432, N(that is, calling system software to add the process element to theprocess element linked list). The lower 16-bits of the process handlemay be the offset of the process element within the process elementlinked list.

FIG. 4D illustrates an exemplary accelerator integration slice 490. Asused herein, a “slice” comprises a specified portion of the processingresources of the accelerator integration circuit 436. Applicationeffective address space 482 within system memory 441 stores processelements 483. The process elements 483 may be stored in response to GPUinvocations 481 from applications 480 executed on the processor 407. Aprocess element 483 contains the process state for the correspondingapplication 480. A work descriptor (WD) 484 contained in the processelement 483 can be a single job requested by an application or maycontain a pointer to a queue of jobs. In the latter case, the WD 484 isa pointer to the job request queue in the application's address space482.

The graphics acceleration module 446 and/or the individual graphicsprocessing engines 431-432, N can be shared by all or a subset of theprocesses in the system. For example, the technologies described hereinmay include an infrastructure for setting up the process state andsending a WD 484 to a graphics acceleration module 446 to start a job ina virtualized environment.

In one implementation, the dedicated-process programming model isimplementation-specific. In this model, a single process owns thegraphics acceleration module 446 or an individual graphics processingengine 431. Because the graphics acceleration module 446 is owned by asingle process, the hypervisor initializes the accelerator integrationcircuit 436 for the owning partition and the operating systeminitializes the accelerator integration circuit 436 for the owningprocess at the time when the graphics acceleration module 446 isassigned.

In operation, a WD fetch unit 491 in the accelerator integration slice490 fetches the next WD 484 which includes an indication of the work tobe done by one of the graphics processing engines of the graphicsacceleration module 446. Data from the WD 484 may be stored in registers445 and used by the MMU 439, interrupt management circuit 447 and/orcontext management circuit 448 as illustrated. For example, the MMU 439may include segment/page walk circuitry for accessing segment/pagetables 486 within the OS virtual address space 485. The interruptmanagement circuit 447 may process interrupt events 492 received fromthe graphics acceleration module 446. When performing graphicsoperations, an effective address 493 generated by a graphics processingengine 431-432, N is translated to a real address by the MMU 439.

The same set of registers 445 may be duplicated for each graphicsprocessing engine 431-432, N and/or graphics acceleration module 446 andmay be initialized by the hypervisor or operating system. Each of theseduplicated registers may be included in an accelerator integration slice490. In one embodiment, each graphics processing engine 431-432, N maybe presented to the hypervisor 496 as a distinct graphics processordevice. QoS settings can be configured for clients of a specificgraphics processing engine 431-432, N and data isolation between theclients of each engine can be enabled. Exemplary registers that may beinitialized by the hypervisor are shown in Table 1.

TABLE 1 Hypervisor Initialized Registers 1 Slice Control Register 2 RealAddress (RA) Scheduled Processes Area Pointer 3 Authority Mask OverrideRegister 4 Interrupt Vector Table Entry Offset 5 Interrupt Vector TableEntry Limit 6 State Register 7 Logical Partition ID 8 Real address (RA)Hypervisor Accelerator Utilization Record Pointer 9 Storage DescriptionRegister

Exemplary registers that may be initialized by the operating system areshown in Table 2.

TABLE 2 Operating System Initialized Registers 1 Process and ThreadIdentification 2 Effective Address (EA) Context Save/Restore Pointer 3Virtual Address (VA) Accelerator Utilization Record Pointer 4 VirtualAddress (VA) Storage Segment Table Pointer 5 Authority Mask 6 Workdescriptor

Each WD 484 may be specific to a particular graphics acceleration module446 and/or graphics processing engine 431-432, N. It contains all theinformation a graphics processing engine 431-432, N requires to do itswork or it can be a pointer to a memory location where the applicationhas set up a command queue of work to be completed.

FIG. 4E illustrates additional optional details of a shared model. Itincludes a hypervisor real address space 498 in which a process elementlist 499 is stored. The hypervisor real address space 498 is accessiblevia a hypervisor 496 which virtualizes the graphics acceleration moduleengines for the operating system 495.

The shared programming models allow for all or a subset of processesfrom all or a subset of partitions in the system to use a graphicsacceleration module 446. There are two programming models where thegraphics acceleration module 446 is shared by multiple processes andpartitions: time-sliced shared and graphics directed shared.

In this model, the system hypervisor 496 owns the graphics accelerationmodule 446 and makes its function available to all operating systems495. For a graphics acceleration module 446 to support virtualization bythe system hypervisor 496, the graphics acceleration module 446 mayadhere to the following requirements: 1) An application's job requestmust be autonomous (that is, the state does not need to be maintainedbetween jobs), or the graphics acceleration module 446 must provide acontext save and restore mechanism. 2) An application's job request isguaranteed by the graphics acceleration module 446 to complete in aspecified amount of time, including any translation faults, or thegraphics acceleration module 446 provides the ability to preempt theprocessing of the job. 3) The graphics acceleration module 446 must beguaranteed fairness between processes when operating in the directedshared programming model.

For the shared model, the application 480 may be required to make anoperating system 495 system call with a graphics acceleration module 446type, a work descriptor (WD), an authority mask register (AMR) value,and a context save/restore area pointer (CSRP). The graphicsacceleration module 446 type describes the targeted accelerationfunction for the system call. The graphics acceleration module 446 typemay be a system-specific value. The WD is formatted specifically for thegraphics acceleration module 446 and can be in the form of a graphicsacceleration module 446 command, an effective address pointer to auser-defined structure, an effective address pointer to a queue ofcommands, or any other data structure to describe the work to be done bythe graphics acceleration module 446. In one embodiment, the AMR valueis the AMR state to use for the current process. The value passed to theoperating system is similar to an application setting the AMR. If theaccelerator integration circuit 436 and graphics acceleration module 446implementations do not support a User Authority Mask Override Register(UAMOR), the operating system may apply the current UAMOR value to theAMR value before passing the AMR in the hypervisor call. The hypervisor496 may optionally apply the current Authority Mask Override Register(AMOR) value before placing the AMR into the process element 483. TheCSRP may be one of the registers 445 containing the effective address ofan area in the application's address space 482 for the graphicsacceleration module 446 to save and restore the context state. Thispointer is optional if no state is required to be saved between jobs orwhen a job is preempted. The context save/restore area may be pinnedsystem memory.

Upon receiving the system call, the operating system 495 may verify thatthe application 480 has registered and been given the authority to usethe graphics acceleration module 446. The operating system 495 thencalls the hypervisor 496 with the information shown in Table 3.

TABLE 3 OS to Hypervisor Call Parameters 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)

Upon receiving the hypervisor call, the hypervisor 496 verifies that theoperating system 495 has registered and been given the authority to usethe graphics acceleration module 446. The hypervisor 496 then puts theprocess element 483 into the process element linked list for thecorresponding graphics acceleration module 446 type. The process elementmay include the information shown in Table 4.

TABLE 4 Process Element Information 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)8 Interrupt vector table, derived from the hypervisor call parameters. 9A state register (SR) value 10 A logical partition ID (LPID) 11 A realaddress (RA) hypervisor accelerator utilization record pointer 12 TheStorage Descriptor Register (SDR)

The hypervisor may initialize a plurality of accelerator integrationslice 490 registers 445.

As illustrated in FIG. 4F, in one optional implementation a unifiedmemory addressable via a common virtual memory address space used toaccess the physical processor memories 401-402 and GPU memories 420-423is employed. In this implementation, operations executed on the GPUs410-413 utilize the same virtual/effective memory address space toaccess the processors memories 401-402 and vice versa, therebysimplifying programmability. A first portion of the virtual/effectiveaddress space may be allocated to the processor memory 401, a secondportion to the second processor memory 402, a third portion to the GPUmemory 420, and so on. The entire virtual/effective memory space(sometimes referred to as the effective address space) may thereby bedistributed across each of the processor memories 401-402 and GPUmemories 420-423, allowing any processor or GPU to access any physicalmemory with a virtual address mapped to that memory.

Bias/coherence management circuitry 494A-494E within one or more of theMMUs 439A-439E may be provided that ensures cache coherence between thecaches of the host processors (e.g., 405) and the GPUs 410-413 andimplements biasing techniques indicating the physical memories in whichcertain types of data should be stored. While multiple instances ofbias/coherence management circuitry 494A-494E are illustrated in FIG.4F, the bias/coherence circuitry may be implemented within the MMU ofone or more host processors 405 and/or within the acceleratorintegration circuit 436.

The GPU-attached memory 420-423 may be mapped as part of system memory,and accessed using shared virtual memory (SVM) technology, but withoutsuffering the typical performance drawbacks associated with full systemcache coherence. The ability to GPU-attached memory 420-423 to beaccessed as system memory without onerous cache coherence overheadprovides a beneficial operating environment for GPU offload. Thisarrangement allows the host processor 405 software to setup operands andaccess computation results, without the overhead of tradition I/O DMAdata copies. Such traditional copies involve driver calls, interruptsand memory mapped I/O (MMIO) accesses that are all inefficient relativeto simple memory accesses. At the same time, the ability to access GPUattached memory 420-423 without cache coherence overheads can becritical to the execution time of an offloaded computation. In caseswith substantial streaming write memory traffic, for example, cachecoherence overhead can significantly reduce the effective writebandwidth seen by a GPU 410-413. The efficiency of operand setup, theefficiency of results access, and the efficiency of GPU computation allplay a role in determining the effectiveness of GPU offload.

A selection between GPU bias and host processor bias may be driven by abias tracker data structure. A bias table may be used, for example,which may be a page-granular structure (i.e., controlled at thegranularity of a memory page) that includes 1 or 2 bits per GPU-attachedmemory page. The bias table may be implemented in a stolen memory rangeof one or more GPU-attached memories 420-423, with or without a biascache in the GPU 410-413 (e.g., to cache frequently/recently usedentries of the bias table). Alternatively, the entire bias table may bemaintained within the GPU.

In one implementation, the bias table entry associated with each accessto the GPU-attached memory 420-423 is accessed prior the actual accessto the GPU memory, causing the following operations. First, localrequests from the GPU 410-413 that find their page in GPU bias areforwarded directly to a corresponding GPU memory 420-423. Local requestsfrom the GPU that find their page in host bias are forwarded to theprocessor 405 (e.g., over a high-speed link as discussed above).Optionally, requests from the processor 405 that find the requested pagein host processor bias complete the request like a normal memory read.Alternatively, requests directed to a GPU-biased page may be forwardedto the GPU 410-413. The GPU may then transition the page to a hostprocessor bias if it is not currently using the page.

The bias state of a page can be changed either by a software-basedmechanism, a hardware-assisted software-based mechanism, or, for alimited set of cases, a purely hardware-based mechanism.

One mechanism for changing the bias state employs an API call (e.g.,OpenCL), which, in turn, calls the GPU's device driver which, in turn,sends a message (or enqueues a command descriptor) to the GPU directingit to change the bias state and, for some transitions, perform a cacheflushing operation in the host. The cache flushing operation is requiredfor a transition from host processor 405 bias to GPU bias, but is notrequired for the opposite transition.

Cache coherency may be maintained by temporarily rendering GPU-biasedpages uncacheable by the host processor 405. To access these pages, theprocessor 405 may request access from the GPU 410 which may or may notgrant access right away, depending on the implementation. Thus, toreduce communication between the host processor 405 and GPU 410 it isbeneficial to ensure that GPU-biased pages are those which are requiredby the GPU but not the host processor 405 and vice versa.

Graphics Processing Pipeline

FIG. 5 illustrates a graphics processing pipeline 500. A graphicsmultiprocessor, such as graphics multiprocessor 234 as in FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B can implement the illustrated graphics processing pipeline 500.The graphics multiprocessor can be included within the parallelprocessing subsystems as described herein, such as the parallelprocessor 200 of FIG. 2A, which may be related to the parallelprocessor(s) 112 of FIG. 1 and may be used in place of one of those. Thevarious parallel processing systems can implement the graphicsprocessing pipeline 500 via one or more instances of the parallelprocessing unit (e.g., parallel processing unit 202 of FIG. 2A) asdescribed herein. For example, a shader unit (e.g., graphicsmultiprocessor 234 of FIG. 2C) may be configured to perform thefunctions of one or more of a vertex processing unit 504, a tessellationcontrol processing unit 508, a tessellation evaluation processing unit512, a geometry processing unit 516, and a fragment/pixel processingunit 524. The functions of data assembler 502, primitive assemblers 506,514, 518, tessellation unit 510, rasterizer 522, and raster operationsunit 526 may also be performed by other processing engines within aprocessing cluster (e.g., processing cluster 214 of FIG. 2A) and acorresponding partition unit (e.g., partition unit 220A-220N of FIG.2A). The graphics processing pipeline 500 may also be implemented usingdedicated processing units for one or more functions. It is alsopossible that one or more portions of the graphics processing pipeline500 are performed by parallel processing logic within a general-purposeprocessor (e.g., CPU). Optionally, one or more portions of the graphicsprocessing pipeline 500 can access on-chip memory (e.g., parallelprocessor memory 222 as in FIG. 2A) via a memory interface 528, whichmay be an instance of the memory interface 218 of FIG. 2A. The graphicsprocessor pipeline 500 may also be implemented via a multi-core group365A as in FIG. 3C.

The data assembler 502 is a processing unit that may collect vertex datafor surfaces and primitives. The data assembler 502 then outputs thevertex data, including the vertex attributes, to the vertex processingunit 504. The vertex processing unit 504 is a programmable executionunit that executes vertex shader programs, lighting and transformingvertex data as specified by the vertex shader programs. The vertexprocessing unit 504 reads data that is stored in cache, local or systemmemory for use in processing the vertex data and may be programmed totransform the vertex data from an object-based coordinate representationto a world space coordinate space or a normalized device coordinatespace.

A first instance of a primitive assembler 506 receives vertex attributesfrom the vertex processing unit 504. The primitive assembler 506readings stored vertex attributes as needed and constructs graphicsprimitives for processing by tessellation control processing unit 508.The graphics primitives include triangles, line segments, points,patches, and so forth, as supported by various graphics processingapplication programming interfaces (APIs).

The tessellation control processing unit 508 treats the input verticesas control points for a geometric patch. The control points aretransformed from an input representation from the patch (e.g., thepatch's bases) to a representation that is suitable for use in surfaceevaluation by the tessellation evaluation processing unit 512. Thetessellation control processing unit 508 can also compute tessellationfactors for edges of geometric patches. A tessellation factor applies toa single edge and quantifies a view-dependent level of detail associatedwith the edge. A tessellation unit 510 is configured to receive thetessellation factors for edges of a patch and to tessellate the patchinto multiple geometric primitives such as line, triangle, orquadrilateral primitives, which are transmitted to a tessellationevaluation processing unit 512. The tessellation evaluation processingunit 512 operates on parameterized coordinates of the subdivided patchto generate a surface representation and vertex attributes for eachvertex associated with the geometric primitives.

A second instance of a primitive assembler 514 receives vertexattributes from the tessellation evaluation processing unit 512, readingstored vertex attributes as needed, and constructs graphics primitivesfor processing by the geometry processing unit 516. The geometryprocessing unit 516 is a programmable execution unit that executesgeometry shader programs to transform graphics primitives received fromprimitive assembler 514 as specified by the geometry shader programs.The geometry processing unit 516 may be programmed to subdivide thegraphics primitives into one or more new graphics primitives andcalculate parameters used to rasterize the new graphics primitives.

The geometry processing unit 516 may be able to add or delete elementsin the geometry stream. The geometry processing unit 516 outputs theparameters and vertices specifying new graphics primitives to primitiveassembler 518. The primitive assembler 518 receives the parameters andvertices from the geometry processing unit 516 and constructs graphicsprimitives for processing by a viewport scale, cull, and clip unit 520.The geometry processing unit 516 reads data that is stored in parallelprocessor memory or system memory for use in processing the geometrydata. The viewport scale, cull, and clip unit 520 performs clipping,culling, and viewport scaling and outputs processed graphics primitivesto a rasterizer 522.

The rasterizer 522 can perform depth culling and other depth-basedoptimizations. The rasterizer 522 also performs scan conversion on thenew graphics primitives to generate fragments and output those fragmentsand associated coverage data to the fragment/pixel processing unit 524.The fragment/pixel processing unit 524 is a programmable execution unitthat is configured to execute fragment shader programs or pixel shaderprograms. The fragment/pixel processing unit 524 transforming fragmentsor pixels received from rasterizer 522, as specified by the fragment orpixel shader programs. For example, the fragment/pixel processing unit524 may be programmed to perform operations included but not limited totexture mapping, shading, blending, texture correction and perspectivecorrection to produce shaded fragments or pixels that are output to araster operations unit 526. The fragment/pixel processing unit 524 canread data that is stored in either the parallel processor memory or thesystem memory for use when processing the fragment data. Fragment orpixel shader programs may be configured to shade at sample, pixel, tile,or other granularities depending on the sampling rate configured for theprocessing units.

The raster operations unit 526 is a processing unit that performs rasteroperations including, but not limited to stencil, z-test, blending, andthe like, and outputs pixel data as processed graphics data to be storedin graphics memory (e.g., parallel processor memory 222 as in FIG. 2A,and/or system memory 104 as in FIG. 1 ), to be displayed on the one ormore display device(s) 110A-110B or for further processing by one of theone or more processor(s) 102 or parallel processor(s) 112. The rasteroperations unit 526 may be configured to compress z or color data thatis written to memory and decompress z or color data that is read frommemory.

Machine Learning Overview

The architecture described above can be applied to perform training andinference operations using machine learning models. Machine learning hasbeen successful at solving many kinds of tasks. The computations thatarise when training and using machine learning algorithms (e.g., neuralnetworks) lend themselves naturally to efficient parallelimplementations. Accordingly, parallel processors such asgeneral-purpose graphics processing units (GPGPUs) have played asignificant role in the practical implementation of deep neuralnetworks. Parallel graphics processors with single instruction, multiplethread (SIMT) architectures are designed to maximize the amount ofparallel processing in the graphics pipeline. In an SIMT architecture,groups of parallel threads attempt to execute program instructionssynchronously together as often as possible to increase processingefficiency. The efficiency provided by parallel machine learningalgorithm implementations allows the use of high capacity networks andenables those networks to be trained on larger datasets.

A machine learning algorithm is an algorithm that can learn based on aset of data. For example, machine learning algorithms can be designed tomodel high-level abstractions within a data set. For example, imagerecognition algorithms can be used to determine which of severalcategories to which a given input belong; regression algorithms canoutput a numerical value given an input; and pattern recognitionalgorithms can be used to generate translated text or perform text tospeech and/or speech recognition.

An exemplary type of machine learning algorithm is a neural network.There are many types of neural networks; a simple type of neural networkis a feedforward network. A feedforward network may be implemented as anacyclic graph in which the nodes are arranged in layers. Typically, afeedforward network topology includes an input layer and an output layerthat are separated by at least one hidden layer. The hidden layertransforms input received by the input layer into a representation thatis useful for generating output in the output layer. The network nodesare fully connected via edges to the nodes in adjacent layers, but thereare no edges between nodes within each layer. Data received at the nodesof an input layer of a feedforward network are propagated (i.e., “fedforward”) to the nodes of the output layer via an activation functionthat calculates the states of the nodes of each successive layer in thenetwork based on coefficients (“weights”) respectively associated witheach of the edges connecting the layers. Depending on the specific modelbeing represented by the algorithm being executed, the output from theneural network algorithm can take various forms.

Before a machine learning algorithm can be used to model a particularproblem, the algorithm is trained using a training data set. Training aneural network involves selecting a network topology, using a set oftraining data representing a problem being modeled by the network, andadjusting the weights until the network model performs with a minimalerror for all instances of the training data set. For example, during asupervised learning training process for a neural network, the outputproduced by the network in response to the input representing aninstance in a training data set is compared to the “correct” labeledoutput for that instance, an error signal representing the differencebetween the output and the labeled output is calculated, and the weightsassociated with the connections are adjusted to minimize that error asthe error signal is backward propagated through the layers of thenetwork. The network is considered “trained” when the errors for each ofthe outputs generated from the instances of the training data set areminimized.

The accuracy of a machine learning algorithm can be affectedsignificantly by the quality of the data set used to train thealgorithm. The training process can be computationally intensive and mayrequire a significant amount of time on a conventional general-purposeprocessor. Accordingly, parallel processing hardware is used to trainmany types of machine learning algorithms. This is particularly usefulfor optimizing the training of neural networks, as the computationsperformed in adjusting the coefficients in neural networks lendthemselves naturally to parallel implementations. Specifically, manymachine learning algorithms and software applications have been adaptedto make use of the parallel processing hardware within general-purposegraphics processing devices.

FIG. 6 is a generalized diagram of a machine learning software stack600. A machine learning application 602 is any logic that can beconfigured to train a neural network using a training dataset or to usea trained deep neural network to implement machine intelligence. Themachine learning application 602 can include training and inferencefunctionality for a neural network and/or specialized software that canbe used to train a neural network before deployment. The machinelearning application 602 can implement any type of machine intelligenceincluding but not limited to image recognition, mapping andlocalization, autonomous navigation, speech synthesis, medical imaging,or language translation. Example machine learning applications 602include, but are not limited to, voice-based virtual assistants, imageor facial recognition algorithms, autonomous navigation, and thesoftware tools that are used to train the machine learning models usedby the machine learning applications 602.

Hardware acceleration for the machine learning application 602 can beenabled via a machine learning framework 604. The machine learningframework 604 can provide a library of machine learning primitives.Machine learning primitives are basic operations that are commonlyperformed by machine learning algorithms. Without the machine learningframework 604, developers of machine learning algorithms would berequired to create and optimize the main computational logic associatedwith the machine learning algorithm, then re-optimize the computationallogic as new parallel processors are developed. Instead, the machinelearning application can be configured to perform the necessarycomputations using the primitives provided by the machine learningframework 604. Exemplary primitives include tensor convolutions,activation functions, and pooling, which are computational operationsthat are performed while training a convolutional neural network (CNN).The machine learning framework 604 can also provide primitives toimplement basic linear algebra subprograms performed by manymachine-learning algorithms, such as matrix and vector operations.Examples of a machine learning framework 604 include, but are notlimited to, TensorFlow, TensorRT, PyTorch, MXNet, Caffee, and otherhigh-level machine learning frameworks.

The machine learning framework 604 can process input data received fromthe machine learning application 602 and generate the appropriate inputto a compute framework 606. The compute framework 606 can abstract theunderlying instructions provided to the GPGPU driver 608 to enable themachine learning framework 604 to take advantage of hardwareacceleration via the GPGPU hardware 610 without requiring the machinelearning framework 604 to have intimate knowledge of the architecture ofthe GPGPU hardware 610. Additionally, the compute framework 606 canenable hardware acceleration for the machine learning framework 604across a variety of types and generations of the GPGPU hardware 610.Exemplary compute frameworks 606 include the CUDA compute framework andassociated machine learning libraries, such as the CUDA Deep NeuralNetwork (cuDNN) library. The machine learning software stack 600 canalso include communication libraries or frameworks to facilitatemulti-GPU and multi-node compute.

GPGPU Machine Learning Acceleration

FIG. 7 illustrates a general-purpose graphics processing unit 700, whichmay be the parallel processor 200 of FIG. 2A or the parallelprocessor(s) 112 of FIG. 1 . The general-purpose processing unit (GPGPU)700 may be configured to provide support for hardware acceleration ofprimitives provided by a machine learning framework to accelerate theprocessing the type of computational workloads associated with trainingdeep neural networks. Additionally, the GPGPU 700 can be linked directlyto other instances of the GPGPU to create a multi-GPU cluster to improvetraining speed for particularly deep neural networks. Primitives arealso supported to accelerate inference operations for deployed neuralnetworks.

The GPGPU 700 includes a host interface 702 to enable a connection witha host processor. The host interface 702 may be a PCI Express interface.However, the host interface can also be a vendor specific communicationsinterface or communications fabric. The GPGPU 700 receives commands fromthe host processor and uses a global scheduler 704 to distributeexecution threads associated with those commands to a set of processingclusters 706A-706H. The processing clusters 706A-706H share a cachememory 708. The cache memory 708 can serve as a higher-level cache forcache memories within the processing clusters 706A-706H. The illustratedprocessing clusters 706A-706H may correspond with processing clusters214A-214N as in FIG. 2A.

The GPGPU 700 includes memory 714A-714B coupled with the processingclusters 706A-706H via a set of memory controllers 712A-712B. The memory714A-714B can include various types of memory devices including dynamicrandom-access memory (DRAM) or graphics random access memory, such assynchronous graphics random access memory (SGRAM), including graphicsdouble data rate (GDDR) memory. The memory 714A-714B may also include 3Dstacked memory, including but not limited to high bandwidth memory(HBM).

Each of the processing clusters 706A-706H may include a set of graphicsmultiprocessors, such as the graphics multiprocessor 234 of FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B, or may include a multi-core group 365A-365N as in FIG. 3C. Thegraphics multiprocessors of the compute cluster include multiple typesof integer and floating-point logic units that can perform computationaloperations at a range of precisions including suited for machinelearning computations. For example, at least a subset of thefloating-point units in each of the processing clusters 706A-706H can beconfigured to perform 16-bit or 32-bit floating point operations, whilea different subset of the floating-point units can be configured toperform 64-bit floating point operations.

Multiple instances of the GPGPU 700 can be configured to operate as acompute cluster. The communication mechanism used by the compute clusterfor synchronization and data exchange varies across embodiments. Forexample, the multiple instances of the GPGPU 700 communicate over thehost interface 702. In one embodiment the GPGPU 700 includes an I/O hub709 that couples the GPGPU 700 with a GPU link 710 that enables a directconnection to other instances of the GPGPU. The GPU link 710 may becoupled to a dedicated GPU-to-GPU bridge that enables communication andsynchronization between multiple instances of the GPGPU 700. Optionally,the GPU link 710 couples with a high-speed interconnect to transmit andreceive data to other GPGPUs or parallel processors. The multipleinstances of the GPGPU 700 may be located in separate data processingsystems and communicate via a network device that is accessible via thehost interface 702. The GPU link 710 may be configured to enable aconnection to a host processor in addition to or as an alternative tothe host interface 702.

While the illustrated configuration of the GPGPU 700 can be configuredto train neural networks, an alternate configuration of the GPGPU 700can be configured for deployment within a high performance or low powerinferencing platform. In an inferencing configuration, the GPGPU 700includes fewer of the processing clusters 706A-706H relative to thetraining configuration. Additionally, memory technology associated withthe memory 714A-714B may differ between inferencing and trainingconfigurations. In one embodiment, the inferencing configuration of theGPGPU 700 can support inferencing specific instructions. For example, aninferencing configuration can provide support for one or more 8-bitinteger dot product instructions, which are commonly used duringinferencing operations for deployed neural networks.

FIG. 8 illustrates a multi-GPU computing system 800. The multi-GPUcomputing system 800 can include a processor 802 coupled to multipleGPGPUs 806A-806D via a host interface switch 804. The host interfaceswitch 804 may be a PCI express switch device that couples the processor802 to a PCI express bus over which the processor 802 can communicatewith the set of GPGPUs 806A-806D. Each of the multiple GPGPUs 806A-806Dcan be an instance of the GPGPU 700 of FIG. 7 . The GPGPUs 806A-806D caninterconnect via a set of high-speed point to point GPU to GPU links816. The high-speed GPU to GPU links can connect to each of the GPGPUs806A-806D via a dedicated GPU link, such as the GPU link 710 as in FIG.7 . The P2P GPU links 816 enable direct communication between each ofthe GPGPUs 806A-806D without requiring communication over the hostinterface bus to which the processor 802 is connected. With GPU-to-GPUtraffic directed to the P2P GPU links, the host interface bus remainsavailable for system memory access or to communicate with otherinstances of the multi-GPU computing system 800, for example, via one ormore network devices. While in FIG. 8 the GPGPUs 806A-806D connect tothe processor 802 via the host interface switch 804, the processor 802may alternatively include direct support for the P2P GPU links 816 andconnect directly to the GPGPUs 806A-806D. In one embodiment the P2P GPUlink 816 enable the multi-GPU computing system 800 to operate as asingle logical GPU.

Machine Learning Neural Network Implementations

The computing architecture described herein can be configured to performthe types of parallel processing that is particularly suited fortraining and deploying neural networks for machine learning. A neuralnetwork can be generalized as a network of functions having a graphrelationship. As is well-known in the art, there are a variety of typesof neural network implementations used in machine learning. Oneexemplary type of neural network is the feedforward network, aspreviously described.

A second exemplary type of neural network is the Convolutional NeuralNetwork (CNN). A CNN is a specialized feedforward neural network forprocessing data having a known, grid-like topology, such as image data.Accordingly, CNNs are commonly used for compute vision and imagerecognition applications, but they also may be used for other types ofpattern recognition such as speech and language processing. The nodes inthe CNN input layer are organized into a set of “filters” (featuredetectors inspired by the receptive fields found in the retina), and theoutput of each set of filters is propagated to nodes in successivelayers of the network. The computations for a CNN include applying theconvolution mathematical operation to each filter to produce the outputof that filter. Convolution is a specialized kind of mathematicaloperation performed by two functions to produce a third function that isa modified version of one of the two original functions. Inconvolutional network terminology, the first function to the convolutioncan be referred to as the input, while the second function can bereferred to as the convolution kernel. The output may be referred to asthe feature map. For example, the input to a convolution layer can be amultidimensional array of data that defines the various color componentsof an input image. The convolution kernel can be a multidimensionalarray of parameters, where the parameters are adapted by the trainingprocess for the neural network.

Recurrent neural networks (RNNs) are a family of feedforward neuralnetworks that include feedback connections between layers. RNNs enablemodeling of sequential data by sharing parameter data across differentparts of the neural network. The architecture for an RNN includescycles. The cycles represent the influence of a present value of avariable on its own value at a future time, as at least a portion of theoutput data from the RNN is used as feedback for processing subsequentinput in a sequence. This feature makes RNNs particularly useful forlanguage processing due to the variable nature in which language datacan be composed.

The figures described below present exemplary feedforward, CNN, and RNNnetworks, as well as describe a general process for respectivelytraining and deploying each of those types of networks. It will beunderstood that these descriptions are exemplary and non-limiting as toany specific embodiment described herein and the concepts illustratedcan be applied generally to deep neural networks and machine learningtechniques in general.

The exemplary neural networks described above can be used to performdeep learning. Deep learning is machine learning using deep neuralnetworks. The deep neural networks used in deep learning are artificialneural networks composed of multiple hidden layers, as opposed toshallow neural networks that include only a single hidden layer. Deeperneural networks are generally more computationally intensive to train.However, the additional hidden layers of the network enable multisteppattern recognition that results in reduced output error relative toshallow machine learning techniques.

Deep neural networks used in deep learning typically include a front-endnetwork to perform feature recognition coupled to a back-end networkwhich represents a mathematical model that can perform operations (e.g.,object classification, speech recognition, etc.) based on the featurerepresentation provided to the model. Deep learning enables machinelearning to be performed without requiring hand crafted featureengineering to be performed for the model. Instead, deep neural networkscan learn features based on statistical structure or correlation withinthe input data. The learned features can be provided to a mathematicalmodel that can map detected features to an output. The mathematicalmodel used by the network is generally specialized for the specific taskto be performed, and different models will be used to perform differenttask.

Once the neural network is structured, a learning model can be appliedto the network to train the network to perform specific tasks. Thelearning model describes how to adjust the weights within the model toreduce the output error of the network. Backpropagation of errors is acommon method used to train neural networks. An input vector ispresented to the network for processing. The output of the network iscompared to the desired output using a loss function and an error valueis calculated for each of the neurons in the output layer. The errorvalues are then propagated backwards until each neuron has an associatederror value which roughly represents its contribution to the originaloutput. The network can then learn from those errors using an algorithm,such as the stochastic gradient descent algorithm, to update the weightsof the of the neural network.

FIG. 9A-9B illustrate an exemplary convolutional neural network. FIG. 9Aillustrates various layers within a CNN. As shown in FIG. 9A, anexemplary CNN used to model image processing can receive input 902describing the red, green, and blue (RGB) components of an input image.The input 902 can be processed by multiple convolutional layers (e.g.,convolutional layer 904, convolutional layer 906). The output from themultiple convolutional layers may optionally be processed by a set offully connected layers 908. Neurons in a fully connected layer have fullconnections to all activations in the previous layer, as previouslydescribed for a feedforward network. The output from the fully connectedlayers 908 can be used to generate an output result from the network.The activations within the fully connected layers 908 can be computedusing matrix multiplication instead of convolution. Not all CNNimplementations make use of fully connected layers 908. For example, insome implementations the convolutional layer 906 can generate output forthe CNN.

The convolutional layers are sparsely connected, which differs fromtraditional neural network configuration found in the fully connectedlayers 908. Traditional neural network layers are fully connected, suchthat every output unit interacts with every input unit. However, theconvolutional layers are sparsely connected because the output of theconvolution of a field is input (instead of the respective state valueof each of the nodes in the field) to the nodes of the subsequent layer,as illustrated. The kernels associated with the convolutional layersperform convolution operations, the output of which is sent to the nextlayer. The dimensionality reduction performed within the convolutionallayers is one aspect that enables the CNN to scale to process largeimages.

FIG. 9B illustrates exemplary computation stages within a convolutionallayer of a CNN. Input to a convolutional layer 912 of a CNN can beprocessed in three stages of a convolutional layer 914. The three stagescan include a convolution stage 916, a detector stage 918, and a poolingstage 920. The convolutional layer 914 can then output data to asuccessive convolutional layer. The final convolutional layer of thenetwork can generate output feature map data or provide input to a fullyconnected layer, for example, to generate a classification value for theinput to the CNN.

In the convolution stage 916 performs several convolutions in parallelto produce a set of linear activations. The convolution stage 916 caninclude an affine transformation, which is any transformation that canbe specified as a linear transformation plus a translation. Affinetransformations include rotations, translations, scaling, andcombinations of these transformations. The convolution stage computesthe output of functions (e.g., neurons) that are connected to specificregions in the input, which can be determined as the local regionassociated with the neuron. The neurons compute a dot product betweenthe weights of the neurons and the region in the local input to whichthe neurons are connected. The output from the convolution stage 916defines a set of linear activations that are processed by successivestages of the convolutional layer 914.

The linear activations can be processed by a detector stage 918. In thedetector stage 918, each linear activation is processed by a non-linearactivation function. The non-linear activation function increases thenonlinear properties of the overall network without affecting thereceptive fields of the convolution layer. Several types of non-linearactivation functions may be used. One particular type is the rectifiedlinear unit (ReLU), which uses an activation function defined asƒ(x)=max(0,x), such that the activation is thresholded at zero.

The pooling stage 920 uses a pooling function that replaces the outputof the convolutional layer 906 with a summary statistic of the nearbyoutputs. The pooling function can be used to introduce translationinvariance into the neural network, such that small translations to theinput do not change the pooled outputs. Invariance to local translationcan be useful in scenarios where the presence of a feature in the inputdata is more important than the precise location of the feature. Varioustypes of pooling functions can be used during the pooling stage 920,including max pooling, average pooling, and l2-norm pooling.Additionally, some CNN implementations do not include a pooling stage.Instead, such implementations substitute and additional convolutionstage having an increased stride relative to previous convolutionstages.

The output from the convolutional layer 914 can then be processed by thenext layer 922. The next layer 922 can be an additional convolutionallayer or one of the fully connected layers 908. For example, the firstconvolutional layer 904 of FIG. 9A can output to the secondconvolutional layer 906, while the second convolutional layer can outputto a first layer of the fully connected layers 908.

FIG. 10 illustrates an exemplary recurrent neural network 1000. In arecurrent neural network (RNN), the previous state of the networkinfluences the output of the current state of the network. RNNs can bebuilt in a variety of ways using a variety of functions. The use of RNNsgenerally revolves around using mathematical models to predict thefuture based on a prior sequence of inputs. For example, an RNN may beused to perform statistical language modeling to predict an upcomingword given a previous sequence of words. The illustrated RNN 1000 can bedescribed has having an input layer 1002 that receives an input vector,hidden layers 1004 to implement a recurrent function, a feedbackmechanism 1005 to enable a ‘memory’ of previous states, and an outputlayer 1006 to output a result. The RNN 1000 operates based ontime-steps. The state of the RNN at a given time step is influencedbased on the previous time step via the feedback mechanism 1005. For agiven time step, the state of the hidden layers 1004 is defined by theprevious state and the input at the current time step. An initial input(x₁) at a first time step can be processed by the hidden layer 1004. Asecond input (x₂) can be processed by the hidden layer 1004 using stateinformation that is determined during the processing of the initialinput (x₁). A given state can be computed as s_(t)=ƒ(Ux_(t)+Ws_(t−1)),where U and W are parameter matrices. The function ƒ is generally anonlinearity, such as the hyperbolic tangent function (Tanh) or avariant of the rectifier function ƒ(x)=max(0,x). However, the specificmathematical function used in the hidden layers 1004 can vary dependingon the specific implementation details of the RNN 1000.

In addition to the basic CNN and RNN networks described, accelerationfor variations on those networks may be enabled. One example RNN variantis the long short term memory (LSTM) RNN. LSTM RNNs are capable oflearning long-term dependencies that may be necessary for processinglonger sequences of language. A variant on the CNN is a convolutionaldeep belief network, which has a structure similar to a CNN and istrained in a manner similar to a deep belief network. A deep beliefnetwork (DBN) is a generative neural network that is composed ofmultiple layers of stochastic (random) variables. DBNs can be trainedlayer-by-layer using greedy unsupervised learning. The learned weightsof the DBN can then be used to provide pre-train neural networks bydetermining an optimal initial set of weights for the neural network. Infurther embodiments, acceleration for reinforcement learning is enabled.In reinforcement learning, an artificial agent learn by interacting withits environment. The agent is configured to optimize certain objectivesto maximize cumulative rewards.

FIG. 11 illustrates training and deployment of a deep neural network.Once a given network has been structured for a task the neural networkis trained using a training dataset 1102. Various training frameworks1104 have been developed to enable hardware acceleration of the trainingprocess. For example, the machine learning framework 604 of FIG. 6 maybe configured as a training framework 1104. The training framework 1104can hook into an untrained neural network 1106 and enable the untrainedneural net to be trained using the parallel processing resourcesdescribed herein to generate a trained neural network 1108.

To start the training process the initial weights may be chosen randomlyor by pre-training using a deep belief network. The training cycle thenbe performed in either a supervised or unsupervised manner.

Supervised learning is a learning method in which training is performedas a mediated operation, such as when the training dataset 1102 includesinput paired with the desired output for the input, or where thetraining dataset includes input having known output and the output ofthe neural network is manually graded. The network processes the inputsand compares the resulting outputs against a set of expected or desiredoutputs. Errors are then propagated back through the system. Thetraining framework 1104 can adjust to adjust the weights that controlthe untrained neural network 1106. The training framework 1104 canprovide tools to monitor how well the untrained neural network 1106 isconverging towards a model suitable to generating correct answers basedon known input data. The training process occurs repeatedly as theweights of the network are adjusted to refine the output generated bythe neural network. The training process can continue until the neuralnetwork reaches a statistically desired accuracy associated with atrained neural net 1108. The trained neural network 1108 can then bedeployed to implement any number of machine learning operations togenerate an inference result 1114 based on input of new data 1112.

Unsupervised learning is a learning method in which the network attemptsto train itself using unlabeled data. Thus, for unsupervised learningthe training dataset 1102 will include input data without any associatedoutput data. The untrained neural network 1106 can learn groupingswithin the unlabeled input and can determine how individual inputs arerelated to the overall dataset. Unsupervised training can be used togenerate a self-organizing map, which is a type of trained neuralnetwork 1108 capable of performing operations useful in reducing thedimensionality of data. Unsupervised training can also be used toperform anomaly detection, which allows the identification of datapoints in an input dataset that deviate from the normal patterns of thedata.

Variations on supervised and unsupervised training may also be employed.Semi-supervised learning is a technique in which in the training dataset1102 includes a mix of labeled and unlabeled data of the samedistribution. Incremental learning is a variant of supervised learningin which input data is continuously used to further train the model.Incremental learning enables the trained neural network 1108 to adapt tothe new data 1112 without forgetting the knowledge instilled within thenetwork during initial training.

Whether supervised or unsupervised, the training process forparticularly deep neural networks may be too computationally intensivefor a single compute node. Instead of using a single compute node, adistributed network of computational nodes can be used to accelerate thetraining process.

FIG. 12A is a block diagram illustrating distributed learning.Distributed learning is a training model that uses multiple distributedcomputing nodes to perform supervised or unsupervised training of aneural network. The distributed computational nodes can each include oneor more host processors and one or more of the general-purposeprocessing nodes, such as the highly parallel general-purpose graphicsprocessing unit 700 as in FIG. 7 . As illustrated, distributed learningcan be performed with model parallelism 1202, data parallelism 1204, ora combination of model and data parallelism 1206.

In model parallelism 1202, different computational nodes in adistributed system can perform training computations for different partsof a single network. For example, each layer of a neural network can betrained by a different processing node of the distributed system. Thebenefits of model parallelism include the ability to scale toparticularly large models. Splitting the computations associated withdifferent layers of the neural network enables the training of verylarge neural networks in which the weights of all layers would not fitinto the memory of a single computational node. In some instances, modelparallelism can be particularly useful in performing unsupervisedtraining of large neural networks.

In data parallelism 1204, the different nodes of the distributed networkhave a complete instance of the model and each node receives a differentportion of the data. The results from the different nodes are thencombined. While different approaches to data parallelism are possible,data parallel training approaches all require a technique of combiningresults and synchronizing the model parameters between each node.Exemplary approaches to combining data include parameter averaging andupdate based data parallelism. Parameter averaging trains each node on asubset of the training data and sets the global parameters (e.g.,weights, biases) to the average of the parameters from each node.Parameter averaging uses a central parameter server that maintains theparameter data. Update based data parallelism is similar to parameteraveraging except that instead of transferring parameters from the nodesto the parameter server, the updates to the model are transferred.Additionally, update based data parallelism can be performed in adecentralized manner, where the updates are compressed and transferredbetween nodes.

Combined model and data parallelism 1206 can be implemented, forexample, in a distributed system in which each computational nodeincludes multiple GPUs. Each node can have a complete instance of themodel with separate GPUs within each node are used to train differentportions of the model.

Distributed training has increased overhead relative to training on asingle machine. However, the parallel processors and GPGPUs describedherein can each implement various techniques to reduce the overhead ofdistributed training, including techniques to enable high bandwidthGPU-to-GPU data transfer and accelerated remote data synchronization.

FIG. 12B is a block diagram illustrating a programmable networkinterface 1210 and data processing unit. The programmable networkinterface 1210 is a programmable network engine that can be used toaccelerate network-based compute tasks within a distributed environment.The programmable network interface 1210 can couple with a host systemvia host interface 1270. The programmable network interface 1210 can beused to accelerate network or storage operations for CPUs or GPUs of thehost system. The host system can be, for example, a node of adistributed learning system used to perform distributed training, forexample, as shown in FIG. 12A. The host system can also be a data centernode within a data center.

In one embodiment, access to remote storage containing model data can beaccelerated by the programmable network interface 1210. For example, theprogrammable network interface 1210 can be configured to present remotestorage devices as local storage devices to the host system. Theprogrammable network interface 1210 can also accelerate remote directmemory access (RDMA) operations performed between GPUs of the hostsystem with GPUs of remote systems. In one embodiment, the programmablenetwork interface 1210 can enable storage functionality such as, but notlimited to NVME-oF. The programmable network interface 1210 can alsoaccelerate encryption, data integrity, compression, and other operationsfor remote storage on behalf of the host system, allowing remote storageto approach the latencies of storage devices that are directly attachedto the host system.

The programmable network interface 1210 can also perform resourceallocation and management on behalf of the host system. Storage securityoperations can be offloaded to the programmable network interface 1210and performed in concert with the allocation and management of remotestorage resources. Network-based operations to manage access to theremote storage that would otherwise by performed by a processor of thehost system can instead be performed by the programmable networkinterface 1210.

In one embodiment, network and/or data security operations can beoffloaded from the host system to the programmable network interface1210. Data center security policies for a data center node can behandled by the programmable network interface 1210 instead of theprocessors of the host system. For example, the programmable networkinterface 1210 can detect and mitigate against an attemptednetwork-based attack (e.g., DDoS) on the host system, preventing theattack from compromising the availability of the host system.

The programmable network interface 1210 can include a system on a chip(SoC 1220) that executes an operating system via multiple processorcores 1222. The processor cores 1222 can include general-purposeprocessor (e.g., CPU) cores. In one embodiment the processor cores 1222can also include one or more GPU cores. The SoC 1220 can executeinstructions stored in a memory device 1240. A storage device 1250 canstore local operating system data. The storage device 1250 and memorydevice 1240 can also be used to cache remote data for the host system.Network ports 1260A-1260B enable a connection to a network or fabric andfacilitate network access for the SoC 1220 and, via the host interface1270, for the host system. The programmable network interface 1210 canalso include an I/O interface 1275, such as a USB interface. The I/Ointerface 1275 can be used to couple external devices to theprogrammable network interface 1210 or as a debug interface. Theprogrammable network interface 1210 also includes a management interface1230 that enables software on the host device to manage and configurethe programmable network interface 1210 and/or SoC 1220. In oneembodiment the programmable network interface 1210 may also include oneor more accelerators or GPUs 1245 to accept offload of parallel computetasks from the SoC 1220, host system, or remote systems coupled via thenetwork ports 1260A-1260B.

Exemplary Machine Learning Applications

Machine learning can be applied to solve a variety of technologicalproblems, including but not limited to computer vision, autonomousdriving and navigation, speech recognition, and language processing.Computer vision has traditionally been one of the most active researchareas for machine learning applications. Applications of computer visionrange from reproducing human visual abilities, such as recognizingfaces, to creating new categories of visual abilities. For example,computer vision applications can be configured to recognize sound wavesfrom the vibrations induced in objects visible in a video. Parallelprocessor accelerated machine learning enables computer visionapplications to be trained using significantly larger training datasetthan previously feasible and enables inferencing systems to be deployedusing low power parallel processors.

Parallel processor accelerated machine learning has autonomous drivingapplications including lane and road sign recognition, obstacleavoidance, navigation, and driving control. Accelerated machine learningtechniques can be used to train driving models based on datasets thatdefine the appropriate responses to specific training input. Theparallel processors described herein can enable rapid training of theincreasingly complex neural networks used for autonomous drivingsolutions and enables the deployment of low power inferencing processorsin a mobile platform suitable for integration into autonomous vehicles.

Parallel processor accelerated deep neural networks have enabled machinelearning approaches to automatic speech recognition (ASR). ASR includesthe creation of a function that computes the most probable linguisticsequence given an input acoustic sequence. Accelerated machine learningusing deep neural networks have enabled the replacement of the hiddenMarkov models (HMMs) and Gaussian mixture models (GMMs) previously usedfor ASR.

Parallel processor accelerated machine learning can also be used toaccelerate natural language processing. Automatic learning procedurescan make use of statistical inference algorithms to produce models thatare robust to erroneous or unfamiliar input. Exemplary natural languageprocessor applications include automatic machine translation betweenhuman languages.

The parallel processing platforms used for machine learning can bedivided into training platforms and deployment platforms. Trainingplatforms are generally highly parallel and include optimizations toaccelerate multi-GPU single node training and multi-node, multi-GPUtraining. Exemplary parallel processors suited for training include thegeneral-purpose graphics processing unit 700 of FIG. 7 and the multi-GPUcomputing system 800 of FIG. 8 . On the contrary, deployed machinelearning platforms generally include lower power parallel processorssuitable for use in products such as cameras, autonomous robots, andautonomous vehicles.

Additionally, machine learning techniques can be applied to accelerateor enhance graphics processing activities. For example, a machinelearning model can be trained to recognize output generated by a GPUaccelerated application and generate an upscaled version of that output.Such techniques can be applied to accelerate the generation of highresolution images for a gaming application. Various other graphicspipeline activities can benefit from the use of machine learning. Forexample, machine learning models can be trained to perform tessellationoperations on geometry data to increase the complexity of geometricmodels, allowing fine-detailed geometry to be automatically generatedfrom geometry of relatively lower detail.

FIG. 13 illustrates an exemplary inferencing system on a chip (SOC) 1300suitable for performing inferencing using a trained model. The SOC 1300can integrate processing components including a media processor 1302, avision processor 1304, a GPGPU 1306 and a multi-core processor 1308. TheGPGPU 1306 may be a GPGPU as described herein, such as the GPGPU 700,and the multi-core processor 1308 may be a multi-core processordescribed herein, such as the multi-core processors 405-406. The SOC1300 can additionally include on-chip memory 1305 that can enable ashared on-chip data pool that is accessible by each of the processingcomponents. The processing components can be optimized for low poweroperation to enable deployment to a variety of machine learningplatforms, including autonomous vehicles and autonomous robots. Forexample, one implementation of the SOC 1300 can be used as a portion ofthe main control system for an autonomous vehicle. Where the SOC 1300 isconfigured for use in autonomous vehicles the SOC is designed andconfigured for compliance with the relevant functional safety standardsof the deployment jurisdiction.

During operation, the media processor 1302 and vision processor 1304 canwork in concert to accelerate computer vision operations. The mediaprocessor 1302 can enable low latency decode of multiple high-resolution(e.g., 4K, 8K) video streams. The decoded video streams can be writtento a buffer in the on-chip memory 1305. The vision processor 1304 canthen parse the decoded video and perform preliminary processingoperations on the frames of the decoded video in preparation ofprocessing the frames using a trained image recognition model. Forexample, the vision processor 1304 can accelerate convolution operationsfor a CNN that is used to perform image recognition on thehigh-resolution video data, while back end model computations areperformed by the GPGPU 1306.

The multi-core processor 1308 can include control logic to assist withsequencing and synchronization of data transfers and shared memoryoperations performed by the media processor 1302 and the visionprocessor 1304. The multi-core processor 1308 can also function as anapplication processor to execute software applications that can make useof the inferencing compute capability of the GPGPU 1306. For example, atleast a portion of the navigation and driving logic can be implementedin software executing on the multi-core processor 1308. Such softwarecan directly issue computational workloads to the GPGPU 1306 or thecomputational workloads can be issued to the multi-core processor 1308,which can offload at least a portion of those operations to the GPGPU1306.

The GPGPU 1306 can include compute clusters such as a low powerconfiguration of the processing clusters 706A-706H withingeneral-purpose graphics processing unit 700. The compute clusterswithin the GPGPU 1306 can support instruction that are specificallyoptimized to perform inferencing computations on a trained neuralnetwork. For example, the GPGPU 1306 can support instructions to performlow precision computations such as 8-bit and 4-bit integer vectoroperations.

Additional System Overview

FIG. 14 is a block diagram of a processing system 1400. The elements ofFIG. 14 having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such. System 1400 may be usedin a single processor desktop system, a multiprocessor workstationsystem, or a server system having a large number of processors 1402 orprocessor cores 1407. The system 1400 may be a processing platformincorporated within a system-on-a-chip (SoC) integrated circuit for usein mobile, handheld, or embedded devices such as withinInternet-of-things (IoT) devices with wired or wireless connectivity toa local or wide area network.

The system 1400 may be a processing system having components thatcorrespond with those of FIG. 1 . For example, in differentconfigurations, processor(s) 1402 or processor core(s) 1407 maycorrespond with processor(s) 102 of FIG. 1 . Graphics processor(s) 1408may correspond with parallel processor(s) 112 of FIG. 1 . Externalgraphics processor 1418 may be one of the add-in device(s) 120 of FIG. 1.

The system 1400 can include, couple with, or be integrated within: aserver-based gaming platform; a game console, including a game and mediaconsole; a mobile gaming console, a handheld game console, or an onlinegame console. The system 1400 may be part of a mobile phone, smartphone, tablet computing device or mobile Internet-connected device suchas a laptop with low internal storage capacity. Processing system 1400can also include, couple with, or be integrated within: a wearabledevice, such as a smart watch wearable device; smart eyewear or clothingenhanced with augmented reality (AR) or virtual reality (VR) features toprovide visual, audio or tactile outputs to supplement real worldvisual, audio or tactile experiences or otherwise provide text, audio,graphics, video, holographic images or video, or tactile feedback; otheraugmented reality (AR) device; or other virtual reality (VR) device. Theprocessing system 1400 may include or be part of a television or set topbox device. The system 1400 can include, couple with, or be integratedwithin a self-driving vehicle such as a bus, tractor trailer, car, motoror electric power cycle, plane or glider (or any combination thereof).The self-driving vehicle may use system 1400 to process the environmentsensed around the vehicle.

The one or more processors 1402 may include one or more processor cores1407 to process instructions which, when executed, perform operationsfor system or user software. The least one of the one or more processorcores 1407 may be configured to process a specific instruction set 1409.The instruction set 1409 may facilitate Complex Instruction SetComputing (CISC), Reduced Instruction Set Computing (RISC), or computingvia a Very Long Instruction Word (VLIW). One or more processor cores1407 may process a different instruction set 1409, which may includeinstructions to facilitate the emulation of other instruction sets.Processor core 1407 may also include other processing devices, such as aDigital Signal Processor (DSP).

The processor 1402 may include cache memory 1404. Depending on thearchitecture, the processor 1402 can have a single internal cache ormultiple levels of internal cache. In some embodiments, the cache memoryis shared among various components of the processor 1402. In someembodiments, the processor 1402 also uses an external cache (e.g., aLevel-3 (L3) cache or Last Level Cache (LLC)) (not shown), which may beshared among processor cores 1407 using known cache coherencytechniques. A register file 1406 can be additionally included inprocessor 1402 and may include different types of registers for storingdifferent types of data (e.g., integer registers, floating pointregisters, status registers, and an instruction pointer register). Someregisters may be general-purpose registers, while other registers may bespecific to the design of the processor 1402.

The one or more processor(s) 1402 may be coupled with one or moreinterface bus(es) 1410 to transmit communication signals such asaddress, data, or control signals between processor 1402 and othercomponents in the system 1400. The interface bus 1410, in one of theseembodiments, can be a processor bus, such as a version of the DirectMedia Interface (DMI) bus. However, processor busses are not limited tothe DMI bus, and may include one or more Peripheral ComponentInterconnect buses (e.g., PCI, PCI express), memory busses, or othertypes of interface busses. For example, the processor(s) 1402 mayinclude an integrated memory controller 1416 and a platform controllerhub 1430. The memory controller 1416 facilitates communication between amemory device and other components of the system 1400, while theplatform controller hub (PCH) 1430 provides connections to I/O devicesvia a local I/O bus.

The memory device 1420 can be a dynamic random-access memory (DRAM)device, a static random-access memory (SRAM) device, flash memorydevice, phase-change memory device, or some other memory device havingsuitable performance to serve as process memory. The memory device 1420can, for example, operate as system memory for the system 1400, to storedata 1422 and instructions 1421 for use when the one or more processors1402 executes an application or process. Memory controller 1416 alsocouples with an optional external graphics processor 1418, which maycommunicate with the one or more graphics processors 1408 in processors1402 to perform graphics and media operations. In some embodiments,graphics, media, and or compute operations may be assisted by anaccelerator 1412 which is a coprocessor that can be configured toperform a specialized set of graphics, media, or compute operations. Forexample, the accelerator 1412 may be a matrix multiplication acceleratorused to optimize machine learning or compute operations. The accelerator1412 can be a ray-tracing accelerator that can be used to performray-tracing operations in concert with the graphics processor 1408. Inone embodiment, an external accelerator 1419 may be used in place of orin concert with the accelerator 1412.

A display device 1411 may be provided that can connect to theprocessor(s) 1402. The display device 1411 can be one or more of aninternal display device, as in a mobile electronic device or a laptopdevice or an external display device attached via a display interface(e.g., DisplayPort, etc.). The display device 1411 can be a head mounteddisplay (HMD) such as a stereoscopic display device for use in virtualreality (VR) applications or augmented reality (AR) applications.

The platform controller hub 1430 may enable peripherals to connect tomemory device 1420 and processor 1402 via a high-speed I/O bus. The I/Operipherals include, but are not limited to, an audio controller 1446, anetwork controller 1434, a firmware interface 1428, a wirelesstransceiver 1426, touch sensors 1425, a data storage device 1424 (e.g.,non-volatile memory, volatile memory, hard disk drive, flash memory,NAND, 3D NAND, 3D XPoint/Optane, etc.). The data storage device 1424 canconnect via a storage interface (e.g., SATA) or via a peripheral bus,such as a Peripheral Component Interconnect bus (e.g., PCI, PCIexpress). The touch sensors 1425 can include touch screen sensors,pressure sensors, or fingerprint sensors. The wireless transceiver 1426can be a Wi-Fi transceiver, a Bluetooth transceiver, or a mobile networktransceiver such as a 3G, 4G, 5G, or Long-Term Evolution (LTE)transceiver. The firmware interface 1428 enables communication withsystem firmware, and can be, for example, a unified extensible firmwareinterface (UEFI). The network controller 1434 can enable a networkconnection to a wired network. In some embodiments, a high-performancenetwork controller (not shown) couples with the interface bus 1410. Theaudio controller 1446 may be a multi-channel high definition audiocontroller. In some of these embodiments the system 1400 includes anoptional legacy I/O controller 1440 for coupling legacy (e.g., PersonalSystem 2 (PS/2)) devices to the system. The platform controller hub 1430can also connect to one or more Universal Serial Bus (USB) controllers1442 connect input devices, such as keyboard and mouse 1443combinations, a camera 1444, or other USB input devices.

It will be appreciated that the system 1400 shown is exemplary and notlimiting, as other types of data processing systems that are differentlyconfigured may also be used. For example, an instance of the memorycontroller 1416 and platform controller hub 1430 may be integrated intoa discrete external graphics processor, such as the external graphicsprocessor 1418. The platform controller hub 1430 and/or memorycontroller 1416 may be external to the one or more processor(s) 1402.For example, the system 1400 can include an external memory controller1416 and platform controller hub 1430, which may be configured as amemory controller hub and peripheral controller hub within a systemchipset that is in communication with the processor(s) 1402.

For example, circuit boards (“sleds”) can be used on which componentssuch as CPUs, memory, and other components are placed are designed forincreased thermal performance. Processing components such as theprocessors may be located on a top side of a sled while near memory,such as DIMMs, are located on a bottom side of the sled. As a result ofthe enhanced airflow provided by this design, the components may operateat higher frequencies and power levels than in typical systems, therebyincreasing performance. Furthermore, the sleds are configured to blindlymate with power and data communication cables in a rack, therebyenhancing their ability to be quickly removed, upgraded, reinstalled,and/or replaced. Similarly, individual components located on the sleds,such as processors, accelerators, memory, and data storage drives, areconfigured to be easily upgraded due to their increased spacing fromeach other. In the illustrative embodiment, the components additionallyinclude hardware attestation features to prove their authenticity.

A data center can utilize a single network architecture (“fabric”) thatsupports multiple other network architectures including Ethernet andOmni-Path. The sleds can be coupled to switches via optical fibers,which provide higher bandwidth and lower latency than typical twistedpair cabling (e.g., Category 5, Category 5e, Category 6, etc.). Due tothe high bandwidth, low latency interconnections and networkarchitecture, the data center may, in use, pool resources, such asmemory, accelerators (e.g., GPUs, graphics accelerators, FPGAs, ASICs,neural network and/or artificial intelligence accelerators, etc.), anddata storage drives that are physically disaggregated, and provide themto compute resources (e.g., processors) on an as needed basis, enablingthe compute resources to access the pooled resources as if they werelocal.

A power supply or source can provide voltage and/or current to system1400 or any component or system described herein. In one example, thepower supply includes an AC to DC (alternating current to directcurrent) adapter to plug into a wall outlet. Such AC power can berenewable energy (e.g., solar power) power source. In one example, thepower source includes a DC power source, such as an external AC to DCconverter. A power source or power supply may also include wirelesscharging hardware to charge via proximity to a charging field. The powersource can include an internal battery, alternating current supply,motion-based power supply, solar power supply, or fuel cell source.

FIG. 15A-15C illustrate computing systems and graphics processors. Theelements of FIG. 15A-15C having the same or similar names as theelements of any other figure herein describe the same elements as in theother figures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such.

FIG. 15A is a block diagram of a processor 1500, which may be a variantof one of the processors 1402 and may be used in place of one of those.Therefore, the disclosure of any features in combination with theprocessor 1500 herein also discloses a corresponding combination withthe processor(s) 1402, but is not limited to such. The processor 1500may have one or more processor cores 1502A-1502N, an integrated memorycontroller 1514, and an integrated graphics processor 1508. Where anintegrated graphics processor 1508 is excluded, the system that includesthe processor will include a graphics processor device within a systemchipset or coupled via a system bus. Processor 1500 can includeadditional cores up to and including additional core 1502N representedby the dashed lined boxes. Each of processor cores 1502A-1502N includesone or more internal cache units 1504A-1504N. In some embodiments eachprocessor core 1502A-1502N also has access to one or more shared cacheunits 1506. The internal cache units 1504A-1504N and shared cache units1506 represent a cache memory hierarchy within the processor 1500. Thecache memory hierarchy may include at least one level of instruction anddata cache within each processor core and one or more levels of sharedmid-level cache, such as a Level 2 (L2), Level 3 (L3), Level 4 (L4), orother levels of cache, where the highest level of cache before externalmemory is classified as the LLC. In some embodiments, cache coherencylogic maintains coherency between the various cache units 1506 and1504A-1504N.

The processor 1500 may also include a set of one or more bus controllerunits 1516 and a system agent core 1510. The one or more bus controllerunits 1516 manage a set of peripheral buses, such as one or more PCI orPCI express busses. System agent core 1510 provides managementfunctionality for the various processor components. The system agentcore 1510 may include one or more integrated memory controllers 1514 tomanage access to various external memory devices (not shown).

For example, one or more of the processor cores 1502A-1502N may includesupport for simultaneous multi-threading. The system agent core 1510includes components for coordinating and operating cores 1502A-1502Nduring multi-threaded processing. System agent core 1510 mayadditionally include a power control unit (PCU), which includes logicand components to regulate the power state of processor cores1502A-1502N and graphics processor 1508.

The processor 1500 may additionally include graphics processor 1508 toexecute graphics processing operations. In some of these embodiments,the graphics processor 1508 couples with the set of shared cache units1506, and the system agent core 1510, including the one or moreintegrated memory controllers 1514. The system agent core 1510 may alsoinclude a display controller 1511 to drive graphics processor output toone or more coupled displays. The display controller 1511 may also be aseparate module coupled with the graphics processor via at least oneinterconnect, or may be integrated within the graphics processor 1508.

A ring-based interconnect unit 1512 may be used to couple the internalcomponents of the processor 1500. However, an alternative interconnectunit may be used, such as a point-to-point interconnect, a switchedinterconnect, or other techniques, including techniques well known inthe art. In some of these embodiments with a ring-based interconnect1512, the graphics processor 1508 couples with the ring-basedinterconnect 1512 via an I/O link 1513.

The exemplary I/O link 1513 represents at least one of multiplevarieties of I/O interconnects, including an on package I/O interconnectwhich facilitates communication between various processor components anda high-performance embedded memory module 1518, such as an eDRAM module.Optionally, each of the processor cores 1502A-1502N and graphicsprocessor 1508 can use embedded memory modules 1518 as a shared LastLevel Cache.

The processor cores 1502A-1502N may, for example, be homogenous coresexecuting the same instruction set architecture. Alternatively, theprocessor cores 1502A-1502N are heterogeneous in terms of instructionset architecture (ISA), where one or more of processor cores 1502A-1502Nexecute a first instruction set, while at least one of the other coresexecutes a subset of the first instruction set or a differentinstruction set. The processor cores 1502A-1502N may be heterogeneous interms of microarchitecture, where one or more cores having a relativelyhigher power consumption couple with one or more power cores having alower power consumption. As another example, the processor cores1502A-1502N are heterogeneous in terms of computational capability.Additionally, processor 1500 can be implemented on one or more chips oras an SoC integrated circuit having the illustrated components, inaddition to other components.

FIG. 15B is a block diagram of hardware logic of a graphics processorcore 1519, according to some embodiments described herein. The graphicsprocessor core 1519, sometimes referred to as a core slice, can be oneor multiple graphics cores within a modular graphics processor. Thegraphics processor core 1519 is exemplary of one graphics core slice,and a graphics processor as described herein may include multiplegraphics core slices based on target power and performance envelopes.Each graphics processor core 1519 can include a fixed function block1530 coupled with multiple sub-cores 1521A-1521F, also referred to assub-slices, that include modular blocks of general-purpose and fixedfunction logic. In one configuration, a sub-core (sub-slice) of themultiple sub-cores 1521A-1521F is an architectural equivalent to agraphics multiprocessor 234 of FIG. 2D, graphics multiprocessor 325 ofFIG. 3A, and/or a multi-core group of the multi-core groups 365A-365N ofFIG. 3C.

The fixed function block 1530 may include a geometry/fixed functionpipeline 1531 that can be shared by all sub-cores in the graphicsprocessor core 1519, for example, in lower performance and/or lowerpower graphics processor implementations. The geometry/fixed functionpipeline 1531 may include a 3D fixed function pipeline (e.g., 3Dpipeline 1612 as in FIG. 16A described below) a video front-end unit, athread spawner and thread dispatcher, and a unified return buffermanager, which manages unified return buffers (e.g., unified returnbuffer 1718 in FIG. 17 , as described below).

The fixed function block 1530 may also include a graphics SoC interface1532, a graphics microcontroller 1533, and a media pipeline 1534. Thegraphics SoC interface 1532 provides an interface between the graphicsprocessor core 1519 and other processor cores within a system on a chipintegrated circuit. The graphics microcontroller 1533 is a programmablesub-processor that is configurable to manage various functions of thegraphics processor core 1519, including thread dispatch, scheduling, andpre-emption. The media pipeline 1534 (e.g., media pipeline 1616 of FIG.16A and FIG. 17 ) includes logic to facilitate the decoding, encoding,pre-processing, and/or post-processing of multimedia data, includingimage and video data. The media pipeline 1534 implement media operationsvia requests to compute or sampling logic within the sub-cores1521-1521F.

The SoC interface 1532 may enable the graphics processor core 1519 tocommunicate with general-purpose application processor cores (e.g.,CPUs) and/or other components within an SoC, including memory hierarchyelements such as a shared last level cache memory, the system RAM,and/or embedded on-chip or on-package DRAM. The SoC interface 1532 canalso enable communication with fixed function devices within the SoC,such as camera imaging pipelines, and enables the use of and/orimplements global memory atomics that may be shared between the graphicsprocessor core 1519 and CPUs within the SoC. The SoC interface 1532 canalso implement power management controls for the graphics processor core1519 and enable an interface between a clock domain of the graphicsprocessor core 1519 and other clock domains within the SoC. Optionally,the SoC interface 1532 enables receipt of command buffers from a commandstreamer and global thread dispatcher that are configured to providecommands and instructions to each of one or more graphics cores within agraphics processor. The commands and instructions can be dispatched tothe media pipeline 1534, when media operations are to be performed, or ageometry and fixed function pipeline (e.g., geometry and fixed functionpipeline 1531, geometry and fixed function pipeline 1537) when graphicsprocessing operations are to be performed.

The graphics microcontroller 1533 can be configured to perform variousscheduling and management tasks for the graphics processor core 1519. Inone configuration the graphics microcontroller 1533 can, for example,perform graphics and/or compute workload scheduling on the variousgraphics parallel engines within execution unit (EU) arrays 1522A-1522F,1524A-1524F within the sub-cores 1521A-1521F. In this workloadscheduling, host software executing on a CPU core of an SoC includingthe graphics processor core 1519 can submit workloads to one of multiplegraphics processor doorbells, which invokes a scheduling operation onthe appropriate graphics engine. Scheduling operations includedetermining which workload to run next, submitting a workload to acommand streamer, pre-empting existing workloads running on an engine,monitoring progress of a workload, and notifying host software when aworkload is complete. Optionally, the graphics microcontroller 1533 canalso facilitate low-power or idle states for the graphics processor core1519, providing the graphics processor core 1519 with the ability tosave and restore registers within the graphics processor core 1519across low-power state transitions independently from the operatingsystem and/or graphics driver software on the system.

The graphics processor core 1519 may have more than or fewer than theillustrated sub-cores 1521A-1521F, up to N modular sub-cores. For eachset of N sub-cores, the graphics processor core 1519 can also includeshared function logic 1535, shared and/or cache memory 1536, ageometry/fixed function pipeline 1537, as well as additional fixedfunction logic 1538 to accelerate various graphics and computeprocessing operations. The shared function logic 1535 can include logicunits associated with the shared function logic 1720 of FIG. 17 (e.g.,sampler, math, and/or inter-thread communication logic) that can beshared by each N sub-cores within the graphics processor core 1519. Theshared and/or cache memory 1536 can be a last-level cache for the set ofN sub-cores 1521A-1521F within the graphics processor core 1519, and canalso serve as shared memory that is accessible by multiple sub-cores.The geometry/fixed function pipeline 1537 can be included instead of thegeometry/fixed function pipeline 1531 within the fixed function block1530 and can include the same or similar logic units.

The graphics processor core 1519 may include additional fixed functionlogic 1538 that can include various fixed function acceleration logicfor use by the graphics processor core 1519. Optionally, the additionalfixed function logic 1538 includes an additional geometry pipeline foruse in position only shading. In position-only shading, two geometrypipelines exist, the full geometry pipeline within the geometry/fixedfunction pipeline 1538, 1531, and a cull pipeline, which is anadditional geometry pipeline which may be included within the additionalfixed function logic 1538. For example, the cull pipeline may be atrimmed down version of the full geometry pipeline. The full pipelineand the cull pipeline can execute different instances of the sameapplication, each instance having a separate context. Position onlyshading can hide long cull runs of discarded triangles, enabling shadingto be completed earlier in some instances. For example, the cullpipeline logic within the additional fixed function logic 1538 canexecute position shaders in parallel with the main application andgenerally generates critical results faster than the full pipeline, asthe cull pipeline fetches and shades only the position attribute of thevertices, without performing rasterization and rendering of the pixelsto the frame buffer. The cull pipeline can use the generated criticalresults to compute visibility information for all the triangles withoutregard to whether those triangles are culled. The full pipeline (whichin this instance may be referred to as a replay pipeline) can consumethe visibility information to skip the culled triangles to shade onlythe visible triangles that are finally passed to the rasterizationphase.

Optionally, the additional fixed function logic 1538 can also includemachine-learning acceleration logic, such as fixed function matrixmultiplication logic, for implementations including optimizations formachine learning training or inferencing.

Within each graphics sub-core 1521A-1521F a set of execution resourcesis included that may be used to perform graphics, media, and computeoperations in response to requests by graphics pipeline, media pipeline,or shader programs. The graphics sub-cores 1521A-1521F include multipleEU arrays 1522A-1522F, 1524A-1524F, thread dispatch and inter-threadcommunication (TD/IC) logic 1523A-1523F, a 3D (e.g., texture) sampler1525A-1525F, a media sampler 1526A-1526F, a shader processor1527A-1527F, and shared local memory (SLM) 1528A-1528F. The EU arrays1522A-1522F, 1524A-1524F each include multiple execution units, whichare general-purpose graphics processing units capable of performingfloating-point and integer/fixed-point logic operations in service of agraphics, media, or compute operation, including graphics, media, orcompute shader programs. The TD/IC logic 1523A-1523F performs localthread dispatch and thread control operations for the execution unitswithin a sub-core and facilitate communication between threads executingon the execution units of the sub-core. The 3D sampler 1525A-1525F canread texture or other 3D graphics related data into memory. The 3Dsampler can read texture data differently based on a configured samplestate and the texture format associated with a given texture. The mediasampler 1526A-1526F can perform similar read operations based on thetype and format associated with media data. For example, each graphicssub-core 1521A-1521F can alternately include a unified 3D and mediasampler. Threads executing on the execution units within each of thesub-cores 1521A-1521F can make use of shared local memory 1528A-1528Fwithin each sub-core, to enable threads executing within a thread groupto execute using a common pool of on-chip memory.

FIG. 15C is a block diagram of general-purpose graphics processing unit(GPGPU) 1570 that can be configured as a graphics processor, e.g. thegraphics processor 1508, and/or compute accelerator, according toembodiments described herein. The GPGPU 1570 can interconnect with hostprocessors (e.g., one or more CPU(s) 1546) and memory 1571, 1572 via oneor more system and/or memory busses. Memory 1571 may be system memorythat can be shared with the one or more CPU(s) 1546, while memory 1572is device memory that is dedicated to the GPGPU 1570. For example,components within the GPGPU 1570 and memory 1572 may be mapped intomemory addresses that are accessible to the one or more CPU(s) 1546.Access to memory 1571 and 1572 may be facilitated via a memorycontroller 1568. The memory controller 1568 may include an internaldirect memory access (DMA) controller 1569 or can include logic toperform operations that would otherwise be performed by a DMAcontroller.

The GPGPU 1570 includes multiple cache memories, including an L2 cache1553, L1 cache 1554, an instruction cache 1555, and shared memory 1556,at least a portion of which may also be partitioned as a cache memory.The GPGPU 1570 also includes multiple compute units 1560A-1560N. Eachcompute unit 1560A-1560N includes a set of vector registers 1561, scalarregisters 1562, vector logic units 1563, and scalar logic units 1564.The compute units 1560A-1560N can also include local shared memory 1565and a program counter 1566. The compute units 1560A-1560N can couplewith a constant cache 1567, which can be used to store constant data,which is data that will not change during the run of kernel or shaderprogram that executes on the GPGPU 1570. The constant cache 1567 may bea scalar data cache and cached data can be fetched directly into thescalar registers 1562.

During operation, the one or more CPU(s) 1546 can write commands intoregisters or memory in the GPGPU 1570 that has been mapped into anaccessible address space. The command processors 1557 can read thecommands from registers or memory and determine how those commands willbe processed within the GPGPU 1570. A thread dispatcher 1558 can then beused to dispatch threads to the compute units 1560A-1560N to performthose commands. Each compute unit 1560A-1560N can execute threadsindependently of the other compute units. Additionally, each computeunit 1560A-1560N can be independently configured for conditionalcomputation and can conditionally output the results of computation tomemory. The command processors 1557 can interrupt the one or more CPU(s)1546 when the submitted commands are complete.

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures provided by embodiments describedherein, e.g. in accordance with FIG. 15A-15C. The elements of FIG.16A-16C having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 16A is a block diagram of a graphics processor 1600, which may be adiscrete graphics processing unit, or may be a graphics processorintegrated with a plurality of processing cores, or other semiconductordevices such as, but not limited to, memory devices or networkinterfaces. The graphics processor 1600 may be a variant of the graphicsprocessor 1508 and may be used in place of the graphics processor 1508.Therefore, the disclosure of any features in combination with thegraphics processor 1508 herein also discloses a correspondingcombination with the graphics processor 1600, but is not limited tosuch. The graphics processor may communicate via a memory mapped I/Ointerface to registers on the graphics processor and with commandsplaced into the processor memory. Graphics processor 1600 may include amemory interface 1614 to access memory. Memory interface 1614 can be aninterface to local memory, one or more internal caches, one or moreshared external caches, and/or to system memory.

Optionally, graphics processor 1600 also includes a display controller1602 to drive display output data to a display device 1618. Displaycontroller 1602 includes hardware for one or more overlay planes for thedisplay and composition of multiple layers of video or user interfaceelements. The display device 1618 can be an internal or external displaydevice. In one embodiment the display device 1618 is a head mounteddisplay device, such as a virtual reality (VR) display device or anaugmented reality (AR) display device. Graphics processor 1600 mayinclude a video codec engine 1606 to encode, decode, or transcode mediato, from, or between one or more media encoding formats, including, butnot limited to Moving Picture Experts Group (MPEG) formats such asMPEG-2, Advanced Video Coding (AVC) formats such as H.264/MPEG-4 AVC,H.265/HEVC, Alliance for Open Media (AOMedia) VP8, VP9, as well as theSociety of Motion Picture & Television Engineers (SMPTE) 421M/VC-1, andJoint Photographic Experts Group (JPEG) formats such as JPEG, and MotionJPEG (MJPEG) formats.

Graphics processor 1600 may include a block image transfer (BLIT) engine1603 to perform two-dimensional (2D) rasterizer operations including,for example, bit-boundary block transfers. However, alternatively, 2Dgraphics operations may be performed using one or more components ofgraphics processing engine (GPE) 1610. In some embodiments, GPE 1610 isa compute engine for performing graphics operations, includingthree-dimensional (3D) graphics operations and media operations.

GPE 1610 may include a 3D pipeline 1612 for performing 3D operations,such as rendering three-dimensional images and scenes using processingfunctions that act upon 3D primitive shapes (e.g., rectangle, triangle,etc.). The 3D pipeline 1612 includes programmable and fixed functionelements that perform various tasks within the element and/or spawnexecution threads to a 3D/Media subsystem 1615. While 3D pipeline 1612can be used to perform media operations, an embodiment of GPE 1610 alsoincludes a media pipeline 1616 that is specifically used to performmedia operations, such as video post-processing and image enhancement.

Media pipeline 1616 may include fixed function or programmable logicunits to perform one or more specialized media operations, such as videodecode acceleration, video de-interlacing, and video encode accelerationin place of, or on behalf of video codec engine 1606. Media pipeline1616 may additionally include a thread spawning unit to spawn threadsfor execution on 3D/Media subsystem 1615. The spawned threads performcomputations for the media operations on one or more graphics executionunits included in 3D/Media subsystem 1615.

The 3D/Media subsystem 1615 may include logic for executing threadsspawned by 3D pipeline 1612 and media pipeline 1616. The pipelines maysend thread execution requests to 3D/Media subsystem 1615, whichincludes thread dispatch logic for arbitrating and dispatching thevarious requests to available thread execution resources. The executionresources include an array of graphics execution units to process the 3Dand media threads. The 3D/Media subsystem 1615 may include one or moreinternal caches for thread instructions and data. Additionally, the3D/Media subsystem 1615 may also include shared memory, includingregisters and addressable memory, to share data between threads and tostore output data.

FIG. 16B illustrates a graphics processor 1620, being a variant of thegraphics processor 1600 and may be used in place of the graphicsprocessor 1600 and vice versa. Therefore, the disclosure of any featuresin combination with the graphics processor 1600 herein also discloses acorresponding combination with the graphics processor 1620, but is notlimited to such. The graphics processor 1620 has a tiled architecture,according to embodiments described herein. The graphics processor 1620may include a graphics processing engine cluster 1622 having multipleinstances of the graphics processing engine 1610 of FIG. 16A within agraphics engine tile 1610A-1610D. Each graphics engine tile 1610A-1610Dcan be interconnected via a set of tile interconnects 1623A-1623F. Eachgraphics engine tile 1610A-1610D can also be connected to a memorymodule or memory device 1626A-1626D via memory interconnects1625A-1625D. The memory devices 1626A-1626D can use any graphics memorytechnology. For example, the memory devices 1626A-1626D may be graphicsdouble data rate (GDDR) memory. The memory devices 1626A-1626D may behigh-bandwidth memory (HBM) modules that can be on-die with theirrespective graphics engine tile 1610A-1610D. The memory devices1626A-1626D may be stacked memory devices that can be stacked on top oftheir respective graphics engine tile 1610A-1610D. Each graphics enginetile 1610A-1610D and associated memory 1626A-1626D may reside onseparate chiplets, which are bonded to a base die or base substrate, asdescribed in further detail in FIG. 24B-24D.

The graphics processor 1620 may be configured with a non-uniform memoryaccess (NUMA) system in which memory devices 1626A-1626D are coupledwith associated graphics engine tiles 1610A-1610D. A given memory devicemay be accessed by graphics engine tiles other than the tile to which itis directly connected. However, access latency to the memory devices1626A-1626D may be lowest when accessing a local tile. In oneembodiment, a cache coherent NUMA (ccNUMA) system is enabled that usesthe tile interconnects 1623A-1623F to enable communication between cachecontrollers within the graphics engine tiles 1610A-1610D to keep aconsistent memory image when more than one cache stores the same memorylocation.

The graphics processing engine cluster 1622 can connect with an on-chipor on-package fabric interconnect 1624. In one embodiment the fabricinterconnect 1624 includes a network processor, network on a chip (NoC),or another switching processor to enable the fabric interconnect 1624 toact as a packet switched fabric interconnect that switches data packetsbetween components of the graphics processor 1620. The fabricinterconnect 1624 can enable communication between graphics engine tiles1610A-1610D and components such as the video codec engine 1606 and oneor more copy engines 1604. The copy engines 1604 can be used to movedata out of, into, and between the memory devices 1626A-1626D and memorythat is external to the graphics processor 1620 (e.g., system memory).The fabric interconnect 1624 can also be used to interconnect thegraphics engine tiles 1610A-1610D. The graphics processor 1620 mayoptionally include a display controller 1602 to enable a connection withan external display device 1618. The graphics processor may also beconfigured as a graphics or compute accelerator. In the acceleratorconfiguration, the display controller 1602 and display device 1618 maybe omitted.

The graphics processor 1620 can connect to a host system via a hostinterface 1628. The host interface 1628 can enable communication betweenthe graphics processor 1620, system memory, and/or other systemcomponents. The host interface 1628 can be, for example, a PCI expressbus or another type of host system interface. For example, the hostinterface 1628 may be an NVLink or NVSwitch interface. The hostinterface 1628 and fabric interconnect 1624 can cooperate to enablemultiple instances of the graphics processor 1620 to act as singlelogical device. Cooperation between the host interface 1628 and fabricinterconnect 1624 can also enable the individual graphics engine tiles1610A-1610D to be presented to the host system as distinct logicalgraphics devices.

FIG. 16C illustrates a compute accelerator 1630, according toembodiments described herein. The compute accelerator 1630 can includearchitectural similarities with the graphics processor 1620 of FIG. 16Band is optimized for compute acceleration. A compute engine cluster 1632can include a set of compute engine tiles 1640A-1640D that includeexecution logic that is optimized for parallel or vector-basedgeneral-purpose compute operations. The compute engine tiles 1640A-1640Dmay not include fixed function graphics processing logic, although insome embodiments one or more of the compute engine tiles 1640A-1640D caninclude logic to perform media acceleration. The compute engine tiles1640A-1640D can connect to memory 1626A-1626D via memory interconnects1625A-1625D. The memory 1626A-1626D and memory interconnects 1625A-1625Dmay be similar technology as in graphics processor 1620, or can bedifferent. The graphics compute engine tiles 1640A-1640D can also beinterconnected via a set of tile interconnects 1623A-1623F and may beconnected with and/or interconnected by a fabric interconnect 1624. Inone embodiment the compute accelerator 1630 includes a large L3 cache1636 that can be configured as a device-wide cache. The computeaccelerator 1630 can also connect to a host processor and memory via ahost interface 1628 in a similar manner as the graphics processor 1620of FIG. 16B.

The compute accelerator 1630 can also include an integrated networkinterface 1642. In one embodiment the integrated network interface 1642includes a network processor and controller logic that enables thecompute engine cluster 1632 to communicate over a physical layerinterconnect 1644 without requiring data to traverse memory of a hostsystem. In one embodiment, one of the compute engine tiles 1640A-1640Dis replaced by network processor logic and data to be transmitted orreceived via the physical layer interconnect 1644 may be transmitteddirectly to or from memory 1626A-1626D. Multiple instances of thecompute accelerator 1630 may be joined via the physical layerinterconnect 1644 into a single logical device. Alternatively, thevarious compute engine tiles 1640A-1640D may be presented as distinctnetwork accessible compute accelerator devices.

Graphics Processing Engine

FIG. 17 is a block diagram of a graphics processing engine 1710 of agraphics processor in accordance with some embodiments. The graphicsprocessing engine (GPE) 1710 may be a version of the GPE 1610 shown inFIG. 16A, and may also represent a graphics engine tile 1610A-1610D ofFIG. 16B. The elements of FIG. 17 having the same or similar names asthe elements of any other figure herein describe the same elements as inthe other figures, can operate or function in a manner similar to that,can comprise the same components, and can be linked to other entities,as those described elsewhere herein, but are not limited to such. Forexample, the 3D pipeline 1612 and media pipeline 1616 of FIG. 16A arealso illustrated in FIG. 17 . The media pipeline 1616 is optional insome embodiments of the GPE 1710 and may not be explicitly includedwithin the GPE 1710. For example and in at least one embodiment, aseparate media and/or image processor is coupled to the GPE 1710.

GPE 1710 may couple with or include a command streamer 1703, whichprovides a command stream to the 3D pipeline 1612 and/or media pipelines1616. Alternatively or additionally, the command streamer 1703 may bedirectly coupled to a unified return buffer 1718. The unified returnbuffer 1718 may be communicatively coupled to a graphics core array1714. Optionally, the command streamer 1703 is coupled with memory,which can be system memory, or one or more of internal cache memory andshared cache memory. The command streamer 1703 may receive commands fromthe memory and sends the commands to 3D pipeline 1612 and/or mediapipeline 1616. The commands are directives fetched from a ring buffer,which stores commands for the 3D pipeline 1612 and media pipeline 1616.The ring buffer can additionally include batch command buffers storingbatches of multiple commands. The commands for the 3D pipeline 1612 canalso include references to data stored in memory, such as but notlimited to vertex and geometry data for the 3D pipeline 1612 and/orimage data and memory objects for the media pipeline 1616. The 3Dpipeline 1612 and media pipeline 1616 process the commands and data byperforming operations via logic within the respective pipelines or bydispatching one or more execution threads to the graphics core array1714. The graphics core array 1714 may include one or more blocks ofgraphics cores (e.g., graphics core(s) 1715A, graphics core(s) 1715B),each block including one or more graphics cores. Each graphics coreincludes a set of graphics execution resources that includesgeneral-purpose and graphics specific execution logic to performgraphics and compute operations, as well as fixed function textureprocessing and/or machine learning and artificial intelligenceacceleration logic.

In various embodiments the 3D pipeline 1612 can include fixed functionand programmable logic to process one or more shader programs, such asvertex shaders, geometry shaders, pixel shaders, fragment shaders,compute shaders, or other shader programs, by processing theinstructions and dispatching execution threads to the graphics corearray 1714. The graphics core array 1714 provides a unified block ofexecution resources for use in processing these shader programs.Multi-purpose execution logic (e.g., execution units) within thegraphics core(s) 1715A-1715B of the graphics core array 1714 includessupport for various 3D API shader languages and can execute multiplesimultaneous execution threads associated with multiple shaders.

The graphics core array 1714 may include execution logic to performmedia functions, such as video and/or image processing. The executionunits may include general-purpose logic that is programmable to performparallel general-purpose computational operations, in addition tographics processing operations. The general-purpose logic can performprocessing operations in parallel or in conjunction with general-purposelogic within the processor core(s) 1407 of FIG. 14 or core 1502A-1502Nas in FIG. 15A.

Output data generated by threads executing on the graphics core array1714 can output data to memory in a unified return buffer (URB) 1718.The URB 1718 can store data for multiple threads. The URB 1718 may beused to send data between different threads executing on the graphicscore array 1714. The URB 1718 may additionally be used forsynchronization between threads on the graphics core array 1714 andfixed function logic within the shared function logic 1720.

Optionally, the graphics core array 1714 may be scalable, such that thearray includes a variable number of graphics cores, each having avariable number of execution units based on the target power andperformance level of GPE 1710. The execution resources may bedynamically scalable, such that execution resources may be enabled ordisabled as needed.

The graphics core array 1714 couples with shared function logic 1720that includes multiple resources that are shared between the graphicscores in the graphics core array. The shared functions within the sharedfunction logic 1720 are hardware logic units that provide specializedsupplemental functionality to the graphics core array 1714. In variousembodiments, shared function logic 1720 includes but is not limited tosampler 1721, math 1722, and inter-thread communication (ITC) 1723logic. Additionally, one or more cache(s) 1725 within the sharedfunction logic 1720 may be implemented.

A shared function is implemented at least in a case where the demand fora given specialized function is insufficient for inclusion within thegraphics core array 1714. Instead a single instantiation of thatspecialized function is implemented as a stand-alone entity in theshared function logic 1720 and shared among the execution resourceswithin the graphics core array 1714. The precise set of functions thatare shared between the graphics core array 1714 and included within thegraphics core array 1714 varies across embodiments. Specific sharedfunctions within the shared function logic 1720 that are usedextensively by the graphics core array 1714 may be included withinshared function logic 1716 within the graphics core array 1714.Optionally, the shared function logic 1716 within the graphics corearray 1714 can include some or all logic within the shared functionlogic 1720. All logic elements within the shared function logic 1720 maybe duplicated within the shared function logic 1716 of the graphics corearray 1714. Alternatively, the shared function logic 1720 is excluded infavor of the shared function logic 1716 within the graphics core array1714.

Execution Units

FIG. 18A-18B illustrate thread execution logic 1800 including an arrayof processing elements employed in a graphics processor core accordingto embodiments described herein. The elements of FIG. 18A-18B having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. FIG. 18A-18B illustrates anoverview of thread execution logic 1800, which may be representative ofhardware logic illustrated with each sub-core 1521A-1521F of FIG. 15B.FIG. 18A is representative of an execution unit within a general-purposegraphics processor, while FIG. 18B is representative of an executionunit that may be used within a compute accelerator.

As illustrated in FIG. 18A, thread execution logic 1800 may include ashader processor 1802, a thread dispatcher 1804, instruction cache 1806,a scalable execution unit array including a plurality of graphicsexecution units 1808A-1808N, a sampler 1810, shared local memory 1811, adata cache 1812, and a data port 1814. Optionally, the scalableexecution unit array can dynamically scale by enabling or disabling oneor more execution units (e.g., any of graphics execution units 1808A,1808B, 1808C, 1808D, through 1808N-1 and 1808N) based on thecomputational requirements of a workload. The included components may beinterconnected via an interconnect fabric that links to each of thecomponents. Thread execution logic 1800 may include one or moreconnections to memory, such as system memory or cache memory, throughone or more of instruction cache 1806, data port 1814, sampler 1810, andgraphics execution units 1808A-1808N. Each execution unit (e.g. 1808A)may be a stand-alone programmable general-purpose computational unitthat is capable of executing multiple simultaneous hardware threadswhile processing multiple data elements in parallel for each thread. Invarious embodiments, the array of execution units 1808A-1808N isscalable to include any number individual execution units.

In some embodiments the graphics execution units 1808A-1808N may beprimarily used to execute shader programs. A shader processor 1802 canprocess the various shader programs and dispatch execution threadsassociated with the shader programs via a thread dispatcher 1804. Thethread dispatcher may include logic to arbitrate thread initiationrequests from the graphics and media pipelines and instantiate therequested threads on one or more execution units in the graphicsexecution units 1808A-1808N. For example, a geometry pipeline candispatch vertex, tessellation, or geometry shaders to the threadexecution logic for processing. Optionally, the thread dispatcher 1804can also process runtime thread spawning requests from the executingshader programs.

In some embodiments, the graphics execution units 1808A-1808N maysupport an instruction set that includes native support for manystandard 3D graphics shader instructions, such that shader programs fromgraphics libraries (e.g., Direct 3D and OpenGL) are executed with aminimal translation. The execution units support vertex and geometryprocessing (e.g., vertex programs, geometry programs, vertex shaders),pixel processing (e.g., pixel shaders, fragment shaders) andgeneral-purpose processing (e.g., compute and media shaders). Each ofthe graphics execution units 1808A-1808N is capable of multi-issuesingle instruction multiple data (SIMD) execution and multi-threadedoperation enables an efficient execution environment in the face ofhigher latency memory accesses. Each hardware thread within eachexecution unit has a dedicated high-bandwidth register file andassociated independent thread-state. Execution is multi-issue per clockto pipelines capable of integer, single and double precision floatingpoint operations, SIMD branch capability, logical operations,transcendental operations, and other miscellaneous operations. Whilewaiting for data from memory or one of the shared functions, dependencylogic within the execution units 1808A-1808N causes a waiting thread tosleep until the requested data has been returned. While the waitingthread is sleeping, hardware resources may be devoted to processingother threads. For example, during a delay associated with a vertexshader operation, an execution unit can perform operations for a pixelshader, fragment shader, or another type of shader program, including adifferent vertex shader, such as vertex shader 2107 illustrated in FIG.21 . Various embodiments can apply to use execution by use of SingleInstruction Multiple Thread (SIMT) as an alternate to use of SIMD or inaddition to use of SIMD. Reference to a SIMD core or operation can applyalso to SIMT or apply to SIMD in combination with SIMT.

Each execution unit in graphics execution units 1808A-1808N operates onarrays of data elements. The number of data elements is the “executionsize,” or the number of channels for the instruction. An executionchannel is a logical unit of execution for data element access, masking,and flow control within instructions. The number of channels may beindependent of the number of physical Arithmetic Logic Units (ALUs),Floating-Point Units (FPUs), or other logic units (e.g., tensor cores,ray tracing cores, etc.) for a particular graphics processor.Additionally, the graphics execution units 1808A-1808N may supportinteger and floating-point data types.

The execution unit instruction set includes SIMD instructions. Thevarious data elements can be stored as a packed data type in a registerand the execution unit will process the various elements based on thedata size of the elements. For example, when operating on a 256-bit widevector, the 256 bits of the vector are stored in a register and theexecution unit operates on the vector as four separate 64-bit packeddata elements (Quad-Word (QW) size data elements), eight separate 32-bitpacked data elements (Double Word (DW) size data elements), sixteenseparate 16-bit packed data elements (Word (W) size data elements), orthirty-two separate 8-bit data elements (byte (B) size data elements).However, different vector widths and register sizes are possible.

Optionally, one or more execution units can be combined into a fusedgraphics execution unit 1809A-1809N having thread control logic(1807A-1807N) that is common to the fused EUs. Multiple EUs can be fusedinto an EU group. Each EU in the fused EU group can be configured toexecute a separate SIMD hardware thread. The number of EUs in a fused EUgroup can vary according to embodiments. Additionally, various SIMDwidths can be performed per-EU, including but not limited to SIMD8,SIMD16, and SIMD32. Each fused graphics execution unit 1809A-1809Nincludes at least two execution units. For example, fused execution unit1809A includes a first EU 1808A, second EU 1808B, and thread controllogic 1807A that is common to the first EU 1808A and the second EU1808B. The thread control logic 1807A controls threads executed on thefused graphics execution unit 1809A, allowing each EU within the fusedexecution units 1809A-1809N to execute using a common instructionpointer register.

One or more internal instruction caches (e.g., 1806) are included in thethread execution logic 1800 to cache thread instructions for theexecution units. One or more data caches (e.g., 1812) may be included inthe thread execution logic 1800 to cache thread data during threadexecution. Threads executing on the execution logic 1800 can also storeexplicitly managed data in the shared local memory 1811. A sampler 1810may be included to provide texture sampling for 3D operations and mediasampling for media operations. Sampler 1810 may include specializedtexture or media sampling functionality to process texture or media dataduring the sampling process before providing the sampled data to anexecution unit.

During execution, the graphics and media pipelines send threadinitiation requests to thread execution logic 1800 via thread spawningand dispatch logic. Once a group of geometric objects has been processedand rasterized into pixel data, pixel processor logic (e.g., pixelshader logic, fragment shader logic, etc.) within the shader processor1802 is invoked to further compute output information and cause resultsto be written to output surfaces (e.g., color buffers, depth buffers,stencil buffers, etc.). A pixel shader or fragment shader may calculatethe values of the various vertex attributes that are to be interpolatedacross the rasterized object. The pixel processor logic within theshader processor 1802 may then execute an application programminginterface (API)-supplied pixel or fragment shader program. To executethe shader program, the shader processor 1802 dispatches threads to anexecution unit (e.g., 1808A) via thread dispatcher 1804. Shaderprocessor 1802 may use texture sampling logic in the sampler 1810 toaccess texture data in texture maps stored in memory. Arithmeticoperations on the texture data and the input geometry data compute pixelcolor data for each geometric fragment, or discards one or more pixelsfrom further processing.

In addition, the data port 1814 may provide a memory access mechanismfor the thread execution logic 1800 to output processed data to memoryfor further processing on a graphics processor output pipeline. The dataport 1814 may include or couple to one or more cache memories (e.g.,data cache 1812) to cache data for memory access via the data port 1814.

Optionally, the execution logic 1800 can also include a ray tracer 1805that can provide ray tracing acceleration functionality. The ray tracer1805 can support a ray tracing instruction set that includesinstructions/functions for ray generation. The ray tracing instructionset can be similar to or different from the ray-tracing instruction setsupported by the ray tracing cores 372 in FIG. 3C.

FIG. 18B illustrates exemplary internal details of an execution unit1808. A graphics execution unit 1808 can include an instruction fetchunit 1837, a general register file array (GRF) 1824, an architecturalregister file array (ARF) 1826, a thread arbiter 1822, a send unit 1830,a branch unit 1832, a set of SIMD floating point units (FPUs) 1834, andoptionally a set of dedicated integer SIMD ALUs 1835. The GRF 1824 andARF 1826 includes the set of general register files and architectureregister files associated with each simultaneous hardware thread thatmay be active in the graphics execution unit 1808. Per threadarchitectural state may be maintained in the ARF 1826, while data usedduring thread execution is stored in the GRF 1824. The execution stateof each thread, including the instruction pointers for each thread, canbe held in thread-specific registers in the ARF 1826.

The graphics execution unit 1808 may have an architecture that is acombination of Simultaneous Multi-Threading (SMT) and fine-grainedInterleaved Multi-Threading (IMT). The architecture may have a modularconfiguration that can be fine-tuned at design time based on a targetnumber of simultaneous threads and number of registers per executionunit, where execution unit resources are divided across logic used toexecute multiple simultaneous threads. The number of logical threadsthat may be executed by the graphics execution unit 1808 is not limitedto the number of hardware threads, and multiple logical threads can beassigned to each hardware thread.

Optionally, the graphics execution unit 1808 can co-issue multipleinstructions, which may each be different instructions. The threadarbiter 1822 of the graphics execution unit 1808 can dispatch theinstructions to one of the send unit 1830, branch unit 1832, or SIMDFPU(s) 1834 for execution. Each execution thread can access 128general-purpose registers within the GRF 1824, where each register canstore 32 bytes, accessible as a SIMD 8-element vector of 32-bit dataelements. Each execution unit thread may have access to 4 Kbytes withinthe GRF 1824, although embodiments are not so limited, and greater orfewer register resources may be provided in other embodiments. Thegraphics execution unit 1808 may be partitioned into seven hardwarethreads that can independently perform computational operations,although the number of threads per execution unit can also varyaccording to embodiments, for example, up to 16 hardware threads may besupported. In an exemplary embodiment, in which seven threads may access4 Kbytes, the GRF 1824 can store a total of 28 Kbytes. In anotherexemplary embodiment, where 16 threads may access 4 Kbytes, the GRF 1824can store a total of 64 Kbytes. The number of threads per execution unitare, however, not limited to those examples and may be more or less thanthe given numbers. Flexible addressing modes can permit registers to beaddressed together to build effectively wider registers or to representstrided rectangular block data structures.

Additionally or alternatively, memory operations, sampler operations,and other longer-latency system communications may be dispatched via“send” instructions that are executed by the message passing send unit1830. Branch instructions may be dispatched to a dedicated branch unit1832 to facilitate SIMD divergence and eventual convergence.

The graphics execution unit 1808 may include one or more SIMD floatingpoint units (FPU(s)) 1834 to perform floating-point operations. TheFPU(s) 1834 may also support integer computation. In some instances, theFPU(s) 1834 can SIMD execute up to M number of 32-bit floating-point (orinteger) operations, or SIMD execute up to 2M 16-bit integer or 16-bitfloating-point operations. Optionally, at least one of the FPU(s)provides extended math capability to support high-throughputtranscendental math functions and double precision 64-bitfloating-point. A set of 8-bit integer SIMD ALUs 1835 may also bepresent, and may be specifically optimized to perform operationsassociated with machine learning computations.

Optionally, arrays of multiple instances of the graphics execution unit1808 can be instantiated in a graphics sub-core grouping (e.g., asub-slice). For scalability, product architects can choose the exactnumber of execution units per sub-core grouping. The execution unit 1808may execute instructions across a plurality of execution channels. Inaddition, each thread executed on the graphics execution unit 1808 maybe executed on a different channel.

FIG. 19 illustrates a further exemplary execution unit 1900. Theelements of FIG. 19 having the same or similar names as the elements ofany other figure herein describe the same elements as in the otherfigures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such. Theexecution unit 1900 may be a compute-optimized execution unit for usein, for example, a compute engine tile 1640A-1640D as in FIG. 16C, butis not limited as such. The execution unit 1900 may also be used in agraphics engine tile 1610A-1610D as in FIG. 16B. The execution unit 1900may include a thread control unit 1901, a thread state unit 1902, aninstruction fetch/prefetch unit 1903, and an instruction decode unit1904. The execution unit 1900 may additionally include a register file1906 that stores registers that can be assigned to hardware threadswithin the execution unit. The execution unit 1900 may additionallyinclude a send unit 1907 and a branch unit 1908. The send unit 1907 andbranch unit 1908 may operate similarly as the send unit 1830 and abranch unit 1832 of the graphics execution unit 1808 of FIG. 18B.

The execution unit 1900 can also include a compute unit 1910 thatincludes multiple different types of functional units. The compute unit1910 may also include an ALU 1911, a systolic array 1912, and a mathunit 1913. The ALU 1911 includes an array of arithmetic logic units. TheALU 1911 can be configured to perform 64-bit, 32-bit, and 16-bit integerand floating-point operations across multiple processing lanes and datachannels and for multiple hardware and/or software threads. The ALU 1911can perform integer and floating-point operations simultaneously (e.g.,within the same clock cycle).

The systolic array 1912 includes a W wide and D deep network of dataprocessing units that can be used to perform vector or otherdata-parallel operations in a systolic manner. The systolic array 1912can be configured to perform various matrix operations, including as dotproduct, outer product, and general matrix-matrix multiplication (GEMM)operations. The systolic array 1912 may support 16-bit floating pointoperations, as well as 8-bit, 4-bit, 2-bit, and binary integeroperations. The systolic array 1912 may be configured to acceleratemachine learning operations. The systolic array 1912 can be configuredwith support for bfloat16, (brain floating point) 16-bit floating pointformat or a tensor float 32-bit floating point format (TF32) that havedifferent numbers of mantissa and exponent bits relative to Institute ofElectrical and Electronics Engineers (IEEE) 754 formats. FP64 formatscan also be supported.

In one embodiment, the systolic array 1912 includes hardware toaccelerate sparse matrix operations. Multiplication operations forsparse regions of input data can be bypassed without sacrificingthroughput. Block sparsity within input matrices can be detected andoperations having known output values can be bypassed. In oneembodiment, the systolic array 1912 includes hardware to enableoperations on sparse data having a compressed representation. Acompressed representation of a sparse matrix stores non-zero values andmetadata that defines the position of the non-zero values within thematrix. Exemplary compressed representations include but are not limitedto compressed tensor representations such as compressed sparse row(CSR), compressed sparse column (CSC), compressed sparse fiber (CSF)representations. Support for compressed representations enableoperations to be performed on input in a compressed tensor formatwithout requiring the compressed representation to be decompressed ordecoded. In such embodiment, operations can be performed only onnon-zero input values and the resulting non-zero output values can bemapped into an output matrix. In some embodiments, hardware support isalso provided for machine-specific lossless data compression formatsthat are used when transmitting data within hardware or across systembusses. Such data may be retained in a compressed format for sparseinput data and the systolic array 1912 can used the compression metadatafor the compressed data to enable operations to be performed on onlynon-zero values, or to enable blocks of zero data input to be bypassedfor multiply operations.

The math unit 1913 can be configured to perform a specific subset ofmathematical operations in an efficient and lower-power manner than thenALU unit 1911. The math unit 1913 can include math logic found in sharedfunction logic of a graphics processing engine provided by otherembodiments described, e.g., the math logic 1722 of the shared functionlogic 1720 of FIG. 17 . The math unit 1913 can be configured to perform32-bit and 64-bit floating point operations.

The thread control unit 1901 includes logic to control the execution ofthreads within the execution unit. The thread control unit 1901 caninclude thread arbitration logic to start, stop, and preempt executionof threads within the execution unit 1900. The thread state unit 1902can be used to store thread state for threads assigned to execute on theexecution unit 1900. Storing the thread state within the execution unit1900 enables the rapid pre-emption of threads when those threads becomeblocked or idle. The instruction fetch/prefetch unit 1903 can fetchinstructions from an instruction cache of higher-level execution logic(e.g., instruction cache 1806 as in FIG. 18A). The instructionfetch/prefetch unit 1903 can also issue prefetch requests forinstructions to be loaded into the instruction cache based on ananalysis of currently executing threads. The instruction decode unit1904 can be used to decode instructions to be executed by the computeunits. The instruction decode unit 1904 can be used as a secondarydecoder to decode complex instructions into constituentmicro-operations.

The execution unit 1900 additionally includes a register file 1906 thatcan be used by hardware threads executing on the execution unit 1900.Registers in the register file 1906 can be divided across the logic usedto execute multiple simultaneous threads within the compute unit 1910 ofthe execution unit 1900. The number of logical threads that may beexecuted by the graphics execution unit 1900 is not limited to thenumber of hardware threads, and multiple logical threads can be assignedto each hardware thread. The size of the register file 1906 can varyacross embodiments based on the number of supported hardware threads.Register renaming may be used to dynamically allocate registers tohardware threads.

FIG. 20 is a block diagram illustrating graphics processor instructionformats 2000. The graphics processor execution units support aninstruction set having instructions in multiple formats. The solid linedboxes illustrate the components that are generally included in anexecution unit instruction, while the dashed lines include componentsthat are optional or that are only included in a sub-set of theinstructions. In some embodiments the graphics processor instructionformats 2000 described and illustrated are macro-instructions, in thatthey are instructions supplied to the execution unit, as opposed tomicro-operations resulting from instruction decode once the instructionis processed. Thus, a single instructions may cause hardware to performmultiple micro-operations

The graphics processor execution units as described herein may nativelysupport instructions in a 128-bit instruction format 2010. A 64-bitcompacted instruction format 2030 is available for some instructionsbased on the selected instruction, instruction options, and number ofoperands. The native 128-bit instruction format 2010 provides access toall instruction options, while some options and operations arerestricted in the 64-bit format 2030. The native instructions availablein the 64-bit format 2030 vary by embodiment. The instruction iscompacted in part using a set of index values in an index field 2013.The execution unit hardware references a set of compaction tables basedon the index values and uses the compaction table outputs to reconstructa native instruction in the 128-bit instruction format 2010. Other sizesand formats of instruction can be used.

For each format, instruction opcode 2012 defines the operation that theexecution unit is to perform. The execution units execute eachinstruction in parallel across the multiple data elements of eachoperand. For example, in response to an add instruction the executionunit performs a simultaneous add operation across each color channelrepresenting a texture element or picture element. By default, theexecution unit performs each instruction across all data channels of theoperands. Instruction control field 2014 may enable control over certainexecution options, such as channels selection (e.g., predication) anddata channel order (e.g., swizzle). For instructions in the 128-bitinstruction format 2010 an exec-size field 2016 limits the number ofdata channels that will be executed in parallel. An exec-size field 2016may not be available for use in the 64-bit compact instruction format2030.

Some execution unit instructions have up to three operands including twosource operands, src0 2020, src1 2022, and one destination operand (dest2018). Other instructions, such as, for example, data manipulationinstructions, dot product instructions, multiply-add instructions, ormultiply-accumulate instructions, can have a third source operand (e.g.,SRC2 2024). The instruction opcode 2012 determines the number of sourceoperands. An instruction's last source operand can be an immediate(e.g., hard-coded) value passed with the instruction. The executionunits may also support multiple destination instructions, where one ormore of the destinations is implied or implicit based on the instructionand/or the specified destination.

The 128-bit instruction format 2010 may include an access/address modefield 2026 specifying, for example, whether direct register addressingmode or indirect register addressing mode is used. When direct registeraddressing mode is used, the register address of one or more operands isdirectly provided by bits in the instruction.

The 128-bit instruction format 2010 may also include an access/addressmode field 2026, which specifies an address mode and/or an access modefor the instruction. The access mode may be used to define a data accessalignment for the instruction. Access modes including a 16-byte alignedaccess mode and a 1-byte aligned access mode may be supported, where thebyte alignment of the access mode determines the access alignment of theinstruction operands. For example, when in a first mode, the instructionmay use byte-aligned addressing for source and destination operands andwhen in a second mode, the instruction may use 16-byte-alignedaddressing for all source and destination operands.

The address mode portion of the access/address mode field 2026 maydetermine whether the instruction is to use direct or indirectaddressing. When direct register addressing mode is used bits in theinstruction directly provide the register address of one or moreoperands. When indirect register addressing mode is used, the registeraddress of one or more operands may be computed based on an addressregister value and an address immediate field in the instruction.

Instructions may be grouped based on opcode 2012 bit-fields to simplifyOpcode decode 2040. For an 8-bit opcode, bits 4, 5, and 6 allow theexecution unit to determine the type of opcode. The precise opcodegrouping shown is merely an example. A move and logic opcode group 2042may include data movement and logic instructions (e.g., move (mov),compare (cmp)). Move and logic group 2042 may share the five leastsignificant bits (LSB), where move (mov) instructions are in the form of0000xxxxb and logic instructions are in the form of 0001xxxxb. A flowcontrol instruction group 2044 (e.g., call, jump (jmp)) includesinstructions in the form of 0010xxxxb (e.g., 0x20). A miscellaneousinstruction group 2046 includes a mix of instructions, includingsynchronization instructions (e.g., wait, send) in the form of 0011xxxxb(e.g., 0x30). A parallel math instruction group 2048 includescomponent-wise arithmetic instructions (e.g., add, multiply (mul)) inthe form of 0100xxxxb (e.g., 0x40). The parallel math instruction group2048 performs the arithmetic operations in parallel across datachannels. The vector math group 2050 includes arithmetic instructions(e.g., dp4) in the form of 0101xxxxb (e.g., 0x50). The vector math groupperforms arithmetic such as dot product calculations on vector operands.The illustrated opcode decode 2040, in one embodiment, can be used todetermine which portion of an execution unit will be used to execute adecoded instruction. For example, some instructions may be designated assystolic instructions that will be performed by a systolic array. Otherinstructions, such as ray-tracing instructions (not shown) can be routedto a ray-tracing core or ray-tracing logic within a slice or partitionof execution logic.

Graphics Pipeline

FIG. 21 is a block diagram of graphics processor 2100, according toanother embodiment. The elements of FIG. 21 having the same or similarnames as the elements of any other figure herein describe the sameelements as in the other figures, can operate or function in a mannersimilar to that, can comprise the same components, and can be linked toother entities, as those described elsewhere herein, but are not limitedto such.

The graphics processor 2100 may include different types of graphicsprocessing pipelines, such as a geometry pipeline 2120, a media pipeline2130, a display engine 2140, thread execution logic 2150, and a renderoutput pipeline 2170. Graphics processor 2100 may be a graphicsprocessor within a multi-core processing system that includes one ormore general-purpose processing cores. The graphics processor may becontrolled by register writes to one or more control registers (notshown) or via commands issued to graphics processor 2100 via a ringinterconnect 2102. Ring interconnect 2102 may couple graphics processor2100 to other processing components, such as other graphics processorsor general-purpose processors. Commands from ring interconnect 2102 areinterpreted by a command streamer 2103, which supplies instructions toindividual components of the geometry pipeline 2120 or the mediapipeline 2130.

Command streamer 2103 may direct the operation of a vertex fetcher 2105that reads vertex data from memory and executes vertex-processingcommands provided by command streamer 2103. The vertex fetcher 2105 mayprovide vertex data to a vertex shader 2107, which performs coordinatespace transformation and lighting operations to each vertex. Vertexfetcher 2105 and vertex shader 2107 may execute vertex-processinginstructions by dispatching execution threads to execution units2152A-2152B via a thread dispatcher 2131.

The execution units 2152A-2152B may be an array of vector processorshaving an instruction set for performing graphics and media operations.The execution units 2152A-2152B may have an attached L1 cache 2151 thatis specific for each array or shared between the arrays. The cache canbe configured as a data cache, an instruction cache, or a single cachethat is partitioned to contain data and instructions in differentpartitions.

A geometry pipeline 2120 may include tessellation components to performhardware-accelerated tessellation of 3D objects. A programmable hullshader 2111 may configure the tessellation operations. A programmabledomain shader 2117 may provide back-end evaluation of tessellationoutput. A tessellator 2113 may operate at the direction of hull shader2111 and contain special purpose logic to generate a set of detailedgeometric objects based on a coarse geometric model that is provided asinput to geometry pipeline 2120. In addition, if tessellation is notused, tessellation components (e.g., hull shader 2111, tessellator 2113,and domain shader 2117) can be bypassed. The tessellation components canoperate based on data received from the vertex shader 2107.

Complete geometric objects may be processed by a geometry shader 2119via one or more threads dispatched to execution units 2152A-2152B, orcan proceed directly to the clipper 2129. The geometry shader mayoperate on entire geometric objects, rather than vertices or patches ofvertices as in previous stages of the graphics pipeline. If thetessellation is disabled the geometry shader 2119 receives input fromthe vertex shader 2107. The geometry shader 2119 may be programmable bya geometry shader program to perform geometry tessellation if thetessellation units are disabled.

Before rasterization, a clipper 2129 processes vertex data. The clipper2129 may be a fixed function clipper or a programmable clipper havingclipping and geometry shader functions. A rasterizer and depth testcomponent 2173 in the render output pipeline 2170 may dispatch pixelshaders to convert the geometric objects into per pixel representations.The pixel shader logic may be included in thread execution logic 2150.Optionally, an application can bypass the rasterizer and depth testcomponent 2173 and access un-rasterized vertex data via a stream outunit 2123.

The graphics processor 2100 has an interconnect bus, interconnectfabric, or some other interconnect mechanism that allows data andmessage passing amongst the major components of the processor. In someembodiments, execution units 2152A-2152B and associated logic units(e.g., L1 cache 2151, sampler 2154, texture cache 2158, etc.)interconnect via a data port 2156 to perform memory access andcommunicate with render output pipeline components of the processor. Asampler 2154, caches 2151, 2158 and execution units 2152A-2152B each mayhave separate memory access paths. Optionally, the texture cache 2158can also be configured as a sampler cache.

The render output pipeline 2170 may contain a rasterizer and depth testcomponent 2173 that converts vertex-based objects into an associatedpixel-based representation. The rasterizer logic may include awindower/masker unit to perform fixed function triangle and linerasterization. An associated render cache 2178 and depth cache 2179 arealso available in some embodiments. A pixel operations component 2177performs pixel-based operations on the data, though in some instances,pixel operations associated with 2D operations (e.g., bit block imagetransfers with blending) are performed by the 2D engine 2141, orsubstituted at display time by the display controller 2143 using overlaydisplay planes. A shared L3 cache 2175 may be available to all graphicscomponents, allowing the sharing of data without the use of main systemmemory.

The media pipeline 2130 may include a media engine 2137 and a videofront-end 2134. Video front-end 2134 may receive pipeline commands fromthe command streamer 2103. The media pipeline 2130 may include aseparate command streamer. Video front-end 2134 may process mediacommands before sending the command to the media engine 2137. Mediaengine 2137 may include thread spawning functionality to spawn threadsfor dispatch to thread execution logic 2150 via thread dispatcher 2131.

The graphics processor 2100 may include a display engine 2140. Thisdisplay engine 2140 may be external to processor 2100 and may couplewith the graphics processor via the ring interconnect 2102, or someother interconnect bus or fabric. Display engine 2140 may include a 2Dengine 2141 and a display controller 2143. Display engine 2140 maycontain special purpose logic capable of operating independently of the3D pipeline. Display controller 2143 may couple with a display device(not shown), which may be a system integrated display device, as in alaptop computer, or an external display device attached via a displaydevice connector.

The geometry pipeline 2120 and media pipeline 2130 maybe configurable toperform operations based on multiple graphics and media programminginterfaces and are not specific to any one application programminginterface (API). A driver software for the graphics processor maytranslate API calls that are specific to a particular graphics or medialibrary into commands that can be processed by the graphics processor.Support may be provided for the Open Graphics Library (OpenGL), OpenComputing Language (OpenCL), and/or Vulkan graphics and compute API, allfrom the Khronos Group. Support may also be provided for the Direct3Dlibrary from the Microsoft Corporation. A combination of these librariesmay be supported. Support may also be provided for the Open SourceComputer Vision Library (OpenCV). A future API with a compatible 3Dpipeline would also be supported if a mapping can be made from thepipeline of the future API to the pipeline of the graphics processor.

Graphics Pipeline Programming

FIG. 22A is a block diagram illustrating a graphics processor commandformat 2200 used for programming graphics processing pipelines, such as,for example, the pipelines described herein in conjunction with FIG.16A, 17, 21 . FIG. 22B is a block diagram illustrating a graphicsprocessor command sequence 2210 according to an embodiment. The solidlined boxes in FIG. 22A illustrate the components that are generallyincluded in a graphics command while the dashed lines include componentsthat are optional or that are only included in a sub-set of the graphicscommands. The exemplary graphics processor command format 2200 of FIG.22A includes data fields to identify a client 2202, a command operationcode (opcode) 2204, and data 2206 for the command. A sub-opcode 2205 anda command size 2208 are also included in some commands.

Client 2202 may specify the client unit of the graphics device thatprocesses the command data. A graphics processor command parser mayexamine the client field of each command to condition the furtherprocessing of the command and route the command data to the appropriateclient unit. The graphics processor client units may include a memoryinterface unit, a render unit, a 2D unit, a 3D unit, and a media unit.Each client unit may have a corresponding processing pipeline thatprocesses the commands. Once the command is received by the client unit,the client unit reads the opcode 2204 and, if present, sub-opcode 2205to determine the operation to perform. The client unit performs thecommand using information in data field 2206. For some commands, anexplicit command size 2208 is expected to specify the size of thecommand. The command parser may automatically determine the size of atleast some of the commands based on the command opcode. Commands may bealigned via multiples of a double word. Other command formats can alsobe used.

The flow diagram in FIG. 22B illustrates an exemplary graphics processorcommand sequence 2210. Software or firmware of a data processing systemthat features an exemplary graphics processor may use a version of thecommand sequence shown to set up, execute, and terminate a set ofgraphics operations. A sample command sequence is shown and describedfor purposes of example only and is not limited to these specificcommands or to this command sequence. Moreover, the commands may beissued as batch of commands in a command sequence, such that thegraphics processor will process the sequence of commands in at leastpartially concurrence.

The graphics processor command sequence 2210 may begin with a pipelineflush command 2212 to cause any active graphics pipeline to complete thecurrently pending commands for the pipeline. Optionally, the 3D pipeline2222 and the media pipeline 2224 may not operate concurrently. Thepipeline flush is performed to cause the active graphics pipeline tocomplete any pending commands. In response to a pipeline flush, thecommand parser for the graphics processor will pause command processinguntil the active drawing engines complete pending operations and therelevant read caches are invalidated. Optionally, any data in the rendercache that is marked ‘dirty’ can be flushed to memory. Pipeline flushcommand 2212 can be used for pipeline synchronization or before placingthe graphics processor into a low power state.

A pipeline select command 2213 may be used when a command sequencerequires the graphics processor to explicitly switch between pipelines.A pipeline select command 2213 may be required only once within anexecution context before issuing pipeline commands unless the context isto issue commands for both pipelines. A pipeline flush command 2212 maybe required immediately before a pipeline switch via the pipeline selectcommand 2213.

A pipeline control command 2214 may configure a graphics pipeline foroperation and may be used to program the 3D pipeline 2222 and the mediapipeline 2224. The pipeline control command 2214 may configure thepipeline state for the active pipeline. The pipeline control command2214 may be used for pipeline synchronization and to clear data from oneor more cache memories within the active pipeline before processing abatch of commands.

Commands related to the return buffer state 2216 may be used toconfigure a set of return buffers for the respective pipelines to writedata. Some pipeline operations require the allocation, selection, orconfiguration of one or more return buffers into which the operationswrite intermediate data during processing. The graphics processor mayalso use one or more return buffers to store output data and to performcross thread communication. The return buffer state 2216 may includeselecting the size and number of return buffers to use for a set ofpipeline operations.

The remaining commands in the command sequence differ based on theactive pipeline for operations. Based on a pipeline determination 2220,the command sequence is tailored to the 3D pipeline 2222 beginning withthe 3D pipeline state 2230 or the media pipeline 2224 beginning at themedia pipeline state 2240.

The commands to configure the 3D pipeline state 2230 include 3D statesetting commands for vertex buffer state, vertex element state, constantcolor state, depth buffer state, and other state variables that are tobe configured before 3D primitive commands are processed. The values ofthese commands are determined at least in part based on the particular3D API in use. The 3D pipeline state 2230 commands may also be able toselectively disable or bypass certain pipeline elements if thoseelements will not be used.

A 3D primitive 2232 command may be used to submit 3D primitives to beprocessed by the 3D pipeline. Commands and associated parameters thatare passed to the graphics processor via the 3D primitive 2232 commandare forwarded to the vertex fetch function in the graphics pipeline. Thevertex fetch function uses the 3D primitive 2232 command data togenerate vertex data structures. The vertex data structures are storedin one or more return buffers. The 3D primitive 2232 command may be usedto perform vertex operations on 3D primitives via vertex shaders. Toprocess vertex shaders, 3D pipeline 2222 dispatches shader executionthreads to graphics processor execution units.

The 3D pipeline 2222 may be triggered via an execute 2234 command orevent. A register may write trigger command executions. An execution maybe triggered via a ‘go’ or ‘kick’ command in the command sequence.Command execution may be triggered using a pipeline synchronizationcommand to flush the command sequence through the graphics pipeline. The3D pipeline will perform geometry processing for the 3D primitives. Onceoperations are complete, the resulting geometric objects are rasterizedand the pixel engine colors the resulting pixels. Additional commands tocontrol pixel shading and pixel back end operations may also be includedfor those operations.

The graphics processor command sequence 2210 may follow the mediapipeline 2224 path when performing media operations. In general, thespecific use and manner of programming for the media pipeline 2224depends on the media or compute operations to be performed. Specificmedia decode operations may be offloaded to the media pipeline duringmedia decode. The media pipeline can also be bypassed and media decodecan be performed in whole or in part using resources provided by one ormore general-purpose processing cores. The media pipeline may alsoinclude elements for general-purpose graphics processor unit (GPGPU)operations, where the graphics processor is used to perform SIMD vectoroperations using computational shader programs that are not explicitlyrelated to the rendering of graphics primitives.

Media pipeline 2224 may be configured in a similar manner as the 3Dpipeline 2222. A set of commands to configure the media pipeline state2240 are dispatched or placed into a command queue before the mediaobject commands 2242. Commands for the media pipeline state 2240 mayinclude data to configure the media pipeline elements that will be usedto process the media objects. This includes data to configure the videodecode and video encode logic within the media pipeline, such as encodeor decode format. Commands for the media pipeline state 2240 may alsosupport the use of one or more pointers to “indirect” state elementsthat contain a batch of state settings.

Media object commands 2242 may supply pointers to media objects forprocessing by the media pipeline. The media objects include memorybuffers containing video data to be processed. Optionally, all mediapipeline states must be valid before issuing a media object command2242. Once the pipeline state is configured and media object commands2242 are queued, the media pipeline 2224 is triggered via an executecommand 2244 or an equivalent execute event (e.g., register write).Output from media pipeline 2224 may then be post processed by operationsprovided by the 3D pipeline 2222 or the media pipeline 2224. GPGPUoperations may be configured and executed in a similar manner as mediaoperations.

Graphics Software Architecture

FIG. 23 illustrates an exemplary graphics software architecture for adata processing system 2300. Such a software architecture may include a3D graphics application 2310, an operating system 2320, and at least oneprocessor 2330. Processor 2330 may include a graphics processor 2332 andone or more general-purpose processor core(s) 2334. The processor 2330may be a variant of the processor 1402 or any other of the processorsdescribed herein. The processor 2330 may be used in place of theprocessor 1402 or any other of the processors described herein.Therefore, the disclosure of any features in combination with theprocessor 1402 or any other of the processors described herein alsodiscloses a corresponding combination with the graphics processor 2332,but is not limited to such. Moreover, the elements of FIG. 23 having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. The graphics application 2310 andoperating system 2320 are each executed in the system memory 2350 of thedata processing system.

3D graphics application 2310 may contain one or more shader programsincluding shader instructions 2312. The shader language instructions maybe in a high-level shader language, such as the High-Level ShaderLanguage (HLSL) of Direct3D, the OpenGL Shader Language (GLSL), and soforth. The application may also include executable instructions 2314 ina machine language suitable for execution by the general-purposeprocessor core 2334. The application may also include graphics objects2316 defined by vertex data.

The operating system 2320 may be a Microsoft® Windows® operating systemfrom the Microsoft Corporation, a proprietary UNIX-like operatingsystem, or an open source UNIX-like operating system using a variant ofthe Linux kernel. The operating system 2320 can support a graphics API2322 such as the Direct3D API, the OpenGL API, or the Vulkan API. Whenthe Direct3D API is in use, the operating system 2320 uses a front-endshader compiler 2324 to compile any shader instructions 2312 in HLSLinto a lower-level shader language. The compilation may be ajust-in-time (JIT) compilation or the application can perform shaderpre-compilation. High-level shaders may be compiled into low-levelshaders during the compilation of the 3D graphics application 2310. Theshader instructions 2312 may be provided in an intermediate form, suchas a version of the Standard Portable Intermediate Representation (SPIR)used by the Vulkan API.

User mode graphics driver 2326 may contain a back-end shader compiler2327 to convert the shader instructions 2312 into a hardware specificrepresentation. When the OpenGL API is in use, shader instructions 2312in the GLSL high-level language are passed to a user mode graphicsdriver 2326 for compilation. The user mode graphics driver 2326 may useoperating system kernel mode functions 2328 to communicate with a kernelmode graphics driver 2329. The kernel mode graphics driver 2329 maycommunicate with graphics processor 2332 to dispatch commands andinstructions.

IP Core Implementations

One or more aspects may be implemented by representative code stored ona machine-readable medium which represents and/or defines logic withinan integrated circuit such as a processor. For example, themachine-readable medium may include instructions which represent variouslogic within the processor. When read by a machine, the instructions maycause the machine to fabricate the logic to perform the techniquesdescribed herein. Such representations, known as “IP cores,” arereusable units of logic for an integrated circuit that may be stored ona tangible, machine-readable medium as a hardware model that describesthe structure of the integrated circuit. The hardware model may besupplied to various customers or manufacturing facilities, which loadthe hardware model on fabrication machines that manufacture theintegrated circuit. The integrated circuit may be fabricated such thatthe circuit performs operations described in association with any of theembodiments described herein.

FIG. 24A is a block diagram illustrating an IP core development system2400 that may be used to manufacture an integrated circuit to performoperations according to an embodiment. The IP core development system2400 may be used to generate modular, re-usable designs that can beincorporated into a larger design or used to construct an entireintegrated circuit (e.g., an SOC integrated circuit). A design facility2430 can generate a software simulation 2410 of an IP core design in ahigh-level programming language (e.g., C/C++). The software simulation2410 can be used to design, test, and verify the behavior of the IP coreusing a simulation model 2412. The simulation model 2412 may includefunctional, behavioral, and/or timing simulations. A register transferlevel (RTL) design 2415 can then be created or synthesized from thesimulation model 2412. The RTL design 2415 is an abstraction of thebehavior of the integrated circuit that models the flow of digitalsignals between hardware registers, including the associated logicperformed using the modeled digital signals. In addition to an RTLdesign 2415, lower-level designs at the logic level or transistor levelmay also be created, designed, or synthesized. Thus, the particulardetails of the initial design and simulation may vary.

The RTL design 2415 or equivalent may be further synthesized by thedesign facility into a hardware model 2420, which may be in a hardwaredescription language (HDL), or some other representation of physicaldesign data. The HDL may be further simulated or tested to verify the IPcore design. The IP core design can be stored for delivery to a 3rdparty fabrication facility 2465 using non-volatile memory 2440 (e.g.,hard disk, flash memory, or any non-volatile storage medium).Alternatively, the IP core design may be transmitted (e.g., via theInternet) over a wired connection 2450 or wireless connection 2460. Thefabrication facility 2465 may then fabricate an integrated circuit thatis based at least in part on the IP core design. The fabricatedintegrated circuit can be configured to perform operations in accordancewith at least one embodiment described herein.

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly 2470. The integrated circuit package assembly 2470illustrates an implementation of one or more processor or acceleratordevices as described herein. The package assembly 2470 includes multipleunits of hardware logic 2472, 2474 connected to a substrate 2480. Thelogic 2472, 2474 may be implemented at least partly in configurablelogic or fixed-functionality logic hardware, and can include one or moreportions of any of the processor core(s), graphics processor(s), orother accelerator devices described herein. Each unit of logic 2472,2474 can be implemented within a semiconductor die and coupled with thesubstrate 2480 via an interconnect structure 2473. The interconnectstructure 2473 may be configured to route electrical signals between thelogic 2472, 2474 and the substrate 2480, and can include interconnectssuch as, but not limited to bumps or pillars. The interconnect structure2473 may be configured to route electrical signals such as, for example,input/output (I/O) signals and/or power or ground signals associatedwith the operation of the logic 2472, 2474. Optionally, the substrate2480 may be an epoxy-based laminate substrate. The substrate 2480 mayalso include other suitable types of substrates. The package assembly2470 can be connected to other electrical devices via a packageinterconnect 2483. The package interconnect 2483 may be coupled to asurface of the substrate 2480 to route electrical signals to otherelectrical devices, such as a motherboard, other chipset, or multi-chipmodule.

The units of logic 2472, 2474 may be electrically coupled with a bridge2482 that is configured to route electrical signals between the logic2472, 2474. The bridge 2482 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2482 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic 2472, 2474.

Although two units of logic 2472, 2474 and a bridge 2482 areillustrated, embodiments described herein may include more or fewerlogic units on one or more dies. The one or more dies may be connectedby zero or more bridges, as the bridge 2482 may be excluded when thelogic is included on a single die. Alternatively, multiple dies or unitsof logic can be connected by one or more bridges. Additionally, multiplelogic units, dies, and bridges can be connected together in otherpossible configurations, including three-dimensional configurations.

FIG. 24C illustrates a package assembly 2490 that includes multipleunits of hardware logic chiplets connected to a substrate 2480 (e.g.,base die). A graphics processing unit, parallel processor, and/orcompute accelerator as described herein can be composed from diversesilicon chiplets that are separately manufactured. In this context, achiplet is an at least partially packaged integrated circuit thatincludes distinct units of logic that can be assembled with otherchiplets into a larger package. A diverse set of chiplets with differentIP core logic can be assembled into a single device. Additionally thechiplets can be integrated into a base die or base chiplet using activeinterposer technology. The concepts described herein enable theinterconnection and communication between the different forms of IPwithin the GPU. IP cores can be manufactured using different processtechnologies and composed during manufacturing, which avoids thecomplexity of converging multiple IPs, especially on a large SoC withseveral flavors IPs, to the same manufacturing process. Enabling the useof multiple process technologies improves the time to market andprovides a cost-effective way to create multiple product SKUs.Additionally, the disaggregated IPs are more amenable to being powergated independently, components that are not in use on a given workloadcan be powered off, reducing overall power consumption.

In various embodiments a package assembly 2490 can include fewer orgreater number of components and chiplets that are interconnected by afabric 2485 or one or more bridges 2487. The chiplets within the packageassembly 2490 may have a 2.5D arrangement usingChip-on-Wafer-on-Substrate stacking in which multiple dies are stackedside-by-side on a silicon interposer that includes through-silicon vias(TSVs) to couple the chiplets with the substrate 2480, which includeselectrical connections to the package interconnect 2483.

In one embodiment, silicon interposer is an active interposer 2489 thatincludes embedded logic in addition to TSVs. In such embodiment, thechiplets within the package assembly 2490 are arranged using 3D face toface die stacking on top of the active interposer 2489. The activeinterposer 2489 can include hardware logic for I/O 2491, cache memory2492, and other hardware logic 2493, in addition to interconnect fabric2485 and a silicon bridge 2487. The fabric 2485 enables communicationbetween the various logic chiplets 2472, 2474 and the logic 2491, 2493within the active interposer 2489. The fabric 2485 may be an NoCinterconnect or another form of packet switched fabric that switchesdata packets between components of the package assembly. For complexassemblies, the fabric 2485 may be a dedicated chiplet enablescommunication between the various hardware logic of the package assembly2490.

Bridge structures 2487 within the active interposer 2489 may be used tofacilitate a point to point interconnect between, for example, logic orI/O chiplets 2474 and memory chiplets 2475. In some implementations,bridge structures 2487 may also be embedded within the substrate 2480.

The hardware logic chiplets can include special purpose hardware logicchiplets 2472, logic or I/O chiplets 2474, and/or memory chiplets 2475.The hardware logic chiplets 2472 and logic or I/O chiplets 2474 may beimplemented at least partly in configurable logic or fixed-functionalitylogic hardware and can include one or more portions of any of theprocessor core(s), graphics processor(s), parallel processors, or otheraccelerator devices described herein. The memory chiplets 2475 can beDRAM (e.g., GDDR, HBM) memory or cache (SRAM) memory. Cache memory 2492within the active interposer 2489 (or substrate 2480) can act as aglobal cache for the package assembly 2490, part of a distributed globalcache, or as a dedicated cache for the fabric 2485

Each chiplet can be fabricated as separate semiconductor die and coupledwith a base die that is embedded within or coupled with the substrate2480. The coupling with the substrate 2480 can be performed via aninterconnect structure 2473. The interconnect structure 2473 may beconfigured to route electrical signals between the various chiplets andlogic within the substrate 2480. The interconnect structure 2473 caninclude interconnects such as, but not limited to bumps or pillars. Insome embodiments, the interconnect structure 2473 may be configured toroute electrical signals such as, for example, input/output (I/O)signals and/or power or ground signals associated with the operation ofthe logic, I/O and memory chiplets. In one embodiment, an additionalinterconnect structure couples the active interposer 2489 with thesubstrate 2480.

The substrate 2480 may be an epoxy-based laminate substrate, however, itis not limited to that and the substrate 2480 may also include othersuitable types of substrates. The package assembly 2490 can be connectedto other electrical devices via a package interconnect 2483. The packageinterconnect 2483 may be coupled to a surface of the substrate 2480 toroute electrical signals to other electrical devices, such as amotherboard, other chipset, or multi-chip module.

A logic or I/O chiplet 2474 and a memory chiplet 2475 may beelectrically coupled via a bridge 2487 that is configured to routeelectrical signals between the logic or I/O chiplet 2474 and a memorychiplet 2475. The bridge 2487 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2487 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic or I/O chiplet 2474and a memory chiplet 2475. The bridge 2487 may also be referred to as asilicon bridge or an interconnect bridge. For example, the bridge 2487is an Embedded Multi-die Interconnect Bridge (EMIB). Alternatively, thebridge 2487 may simply be a direct connection from one chiplet toanother chiplet.

FIG. 24D illustrates a package assembly 2494 including interchangeablechiplets 2495, according to an embodiment. The interchangeable chiplets2495 can be assembled into standardized slots on one or more basechiplets 2496, 2498. The base chiplets 2496, 2498 can be coupled via abridge interconnect 2497, which can be similar to the other bridgeinterconnects described herein and may be, for example, an EMIB. Memorychiplets can also be connected to logic or I/O chiplets via a bridgeinterconnect. I/O and logic chiplets can communicate via an interconnectfabric. The base chiplets can each support one or more slots in astandardized format for one of logic or I/O or memory/cache.

SRAM and power delivery circuits may be fabricated into one or more ofthe base chiplets 2496, 2498, which can be fabricated using a differentprocess technology relative to the interchangeable chiplets 2495 thatare stacked on top of the base chiplets. For example, the base chiplets2496, 2498 can be fabricated using a larger process technology, whilethe interchangeable chiplets can be manufactured using a smaller processtechnology. One or more of the interchangeable chiplets 2495 may bememory (e.g., DRAM) chiplets. Different memory densities can be selectedfor the package assembly 2494 based on the power, and/or performancetargeted for the product that uses the package assembly 2494.Additionally, logic chiplets with a different number of type offunctional units can be selected at time of assembly based on the power,and/or performance targeted for the product. Additionally, chipletscontaining IP logic cores of differing types can be inserted into theinterchangeable chiplet slots, enabling hybrid processor designs thatcan mix and match different technology IP blocks.

Exemplary System on a Chip Integrated Circuit

FIG. 25-26B illustrate exemplary integrated circuits and associatedgraphics processors that may be fabricated using one or more IP cores.In addition to what is illustrated, other logic and circuits may beincluded, including additional graphics processors/cores, peripheralinterface controllers, or general-purpose processor cores. The elementsof FIG. 25-26B having the same or similar names as the elements of anyother figure herein describe the same elements as in the other figures,can operate or function in a manner similar to that, can comprise thesame components, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 25 is a block diagram illustrating an exemplary system on a chipintegrated circuit 2500 that may be fabricated using one or more IPcores. Exemplary integrated circuit 2500 includes one or moreapplication processor(s) 2505 (e.g., CPUs), at least one graphicsprocessor 2510, which may be a variant of the graphics processor 1408,1508, 2510, or of any graphics processor described herein and may beused in place of any graphics processor described. Therefore, thedisclosure of any features in combination with a graphics processorherein also discloses a corresponding combination with the graphicsprocessor 2510, but is not limited to such. The integrated circuit 2500may additionally include an image processor 2515 and/or a videoprocessor 2520, any of which may be a modular IP core from the same ormultiple different design facilities. Integrated circuit 2500 mayinclude peripheral or bus logic including a USB controller 2525, UARTcontroller 2530, an SPI/SDIO controller 2535, and an I²S/I²C controller2540. Additionally, the integrated circuit can include a display device2545 coupled to one or more of a high-definition multimedia interface(HDMI) controller 2550 and a mobile industry processor interface (MIPI)display interface 2555. Storage may be provided by a flash memorysubsystem 2560 including flash memory and a flash memory controller.Memory interface may be provided via a memory controller 2565 for accessto SDRAM or SRAM memory devices. Some integrated circuits additionallyinclude an embedded security engine 2570.

FIG. 26A-26B are block diagrams illustrating exemplary graphicsprocessors for use within an SoC, according to embodiments describedherein. The graphics processors may be variants of the graphicsprocessor 1408, 1508, 2510, or any other graphics processor describedherein. The graphics processors may be used in place of the graphicsprocessor 1408, 1508, 2510, or any other of the graphics processorsdescribed herein. Therefore, the disclosure of any features incombination with the graphics processor 1408, 1508, 2510, or any otherof the graphics processors described herein also discloses acorresponding combination with the graphics processors of FIG. 26A-26B,but is not limited to such. FIG. 26A illustrates an exemplary graphicsprocessor 2610 of a system on a chip integrated circuit that may befabricated using one or more IP cores, according to an embodiment. FIG.26B illustrates an additional exemplary graphics processor 2640 of asystem on a chip integrated circuit that may be fabricated using one ormore IP cores, according to an embodiment. Graphics processor 2610 ofFIG. 26A is an example of a low power graphics processor core. Graphicsprocessor 2640 of FIG. 26B is an example of a higher performancegraphics processor core. For example, each of graphics processor 2610and graphics processor 2640 can be a variant of the graphics processor2510 of FIG. 25 , as mentioned at the outset of this paragraph.

As shown in FIG. 26A, graphics processor 2610 includes a vertexprocessor 2605 and one or more fragment processor(s) 2615A-2615N (e.g.,2615A, 2615B, 2615C, 2615D, through 2615N-1, and 2615N). Graphicsprocessor 2610 can execute different shader programs via separate logic,such that the vertex processor 2605 is optimized to execute operationsfor vertex shader programs, while the one or more fragment processor(s)2615A-2615N execute fragment (e.g., pixel) shading operations forfragment or pixel shader programs. The vertex processor 2605 performsthe vertex processing stage of the 3D graphics pipeline and generatesprimitives and vertex data. The fragment processor(s) 2615A-2615N usethe primitive and vertex data generated by the vertex processor 2605 toproduce a framebuffer that is displayed on a display device. Thefragment processor(s) 2615A-2615N may be optimized to execute fragmentshader programs as provided for in the OpenGL API, which may be used toperform similar operations as a pixel shader program as provided for inthe Direct 3D API.

Graphics processor 2610 additionally includes one or more memorymanagement units (MMUs) 2620A-2620B, cache(s) 2625A-2625B, and circuitinterconnect(s) 2630A-2630B. The one or more MMU(s) 2620A-2620B providefor virtual to physical address mapping for the graphics processor 2610,including for the vertex processor 2605 and/or fragment processor(s)2615A-2615N, which may reference vertex or image/texture data stored inmemory, in addition to vertex or image/texture data stored in the one ormore cache(s) 2625A-2625B. The one or more MMU(s) 2620A-2620B may besynchronized with other MMUs within the system, including one or moreMMUs associated with the one or more application processor(s) 2505,image processor 2515, and/or video processor 2520 of FIG. 25 , such thateach processor 2505-2520 can participate in a shared or unified virtualmemory system. Components of graphics processor 2610 may correspond withcomponents of other graphics processors described herein. The one ormore MMU(s) 2620A-2620B may correspond with MMU 245 of FIG. 2C. Vertexprocessor 2605 and fragment processor 2615A-2615N may correspond withgraphics multiprocessor 234. The one or more circuit interconnect(s)2630A-2630B enable graphics processor 2610 to interface with other IPcores within the SoC, either via an internal bus of the SoC or via adirect connection, according to embodiments. The one or more circuitinterconnect(s) 2630A-2630B may correspond with the data crossbar 240 ofFIG. 2C. Further correspondence may be found between analogouscomponents of the graphics processor 2610 and the various graphicsprocessor architectures described herein.

As shown FIG. 26B, graphics processor 2640 includes the one or moreMMU(s) 2620A-2620B, cache(s) 2625A-2625B, and circuit interconnect(s)2630A-2630B of the graphics processor 2610 of FIG. 26A. Graphicsprocessor 2640 includes one or more shader cores 2655A-2655N (e.g.,2655A, 2655B, 2655C, 2655D, 2655E, 2655F, through 2655N-1, and 2655N),which provides for a unified shader core architecture in which a singlecore or type or core can execute all types of programmable shader code,including shader program code to implement vertex shaders, fragmentshaders, and/or compute shaders. The exact number of shader corespresent can vary among embodiments and implementations. Additionally,graphics processor 2640 includes an inter-core task manager 2645, whichacts as a thread dispatcher to dispatch execution threads to one or moreshader cores 2655A-2655N and a tiling unit 2658 to accelerate tilingoperations for tile-based rendering, in which rendering operations for ascene are subdivided in image space, for example to exploit localspatial coherence within a scene or to optimize use of internal caches.Shader cores 2655A-2655N may correspond with, for example, graphicsmultiprocessor 234 as in FIG. 2D, or graphics multiprocessors 325, 350of FIGS. 3A and 3B respectively, or multi-core group 365A of FIG. 3C.

Tensor Acceleration Logic for Graphics and Machine Learning Workloads

FIG. 27 is a block diagram of a data processing system 2700, accordingto an embodiment. The data processing system 2700 is a heterogeneousprocessing system having a processor 2702, unified memory 2710, and aGPGPU 2720 including machine learning acceleration logic. The processor2702 and the GPGPU 2720 can be any of the processors and GPGPU/parallelprocessors as described herein. For example, with additional referenceto FIG. 1 , processor 2702 can be a variant of and/or share anarchitecture with a processor of the illustrated one or moreprocessor(s) 102 and the GPGPU 2720 can be a variant of and/or share anarchitecture with a parallel processor of the illustrated one or moreparallel processor(s) 112. With additional reference to FIG. 14 ,processor 2702 can be a variant of and/or share an architecture with oneof the illustrated processor(s) 1402 and the GPGPU 2720 can be a variantof and/or share an architecture with one of the illustrated graphicsprocessor(s) 1408.

The processor 2702 can execute instructions for a compiler 2715 storedin system memory 2712. The compiler 2715 executes on the processor 2702to compile source code 2714A into compiled code 2714B. The compiled code2714B can include instructions that may be executed by the processor2702 and/or instructions that may be executed by the GPGPU 2720.Compilation of instructions to be executed by the GPGPU can befacilitated using shader or compute program compilers, such as shadercompiler 2327 and/or shader compiler 2324 as in FIG. 23 . Duringcompilation, the compiler 2715 can perform operations to insertmetadata, including hints as to the level of data parallelism present inthe compiled code 2714B and/or hints regarding the data localityassociated with threads to be dispatched based on the compiled code2714B. The compiler 2715 can include the information necessary toperform such operations or the operations can be performed with theassistance of a runtime library 2716. The runtime library 2716 can alsoassist the compiler 2715 in the compilation of the source code 2714A andcan also include instructions that are linked at runtime with thecompiled code 2714B to facilitate execution of the compiled instructionson the GPGPU 2720. The compiler 2715 can also facilitate registerallocation for variables via a register allocator (RA) and generate loadand store instructions to move data for variables between memory and theregister assigned for the variable.

The unified memory 2710 represents a unified address space that may beaccessed by the processor 2702 and the GPGPU 2720. The unified memorycan include system memory 2712 as well as GPGPU memory 2718. The GPGPUmemory 2718 is memory within an address pace of the GPGPU 2720 and caninclude some or all of system memory 2712. In one embodiment the GPGPUmemory 2718 can also include at least a portion of any memory dedicatedfor use exclusively by the GPGPU 2720. In one embodiment, compiled code2714B stored in system memory 2712 can be mapped into GPGPU memory 2718for access by the GPGPU 2720.

The GPGPU 2720 includes multiple compute blocks 2724A-2724N, which caninclude one or more of a variety of processing resources describedherein. The processing resources can be or include a variety ofdifferent computational resources such as, for example, execution units,compute units, streaming multiprocessors, graphics multiprocessors, ormulti-core groups. In one embodiment the GPGPU 2720 additionallyincludes a tensor accelerator 2723 (e.g., matrix accelerator), which caninclude one or more special function compute units that are designed toaccelerate a subset of matrix operations (e.g., dot product, etc.). Thetensor accelerator 2723 may also be referred to as a tensor acceleratoror tensor core. In one embodiment, logic components within the tensoraccelerator 2723 may be distributed across the processing resources ofthe multiple compute blocks 2724A-2724N.

The GPGPU 2720 can also include a set of resources that can be shared bythe compute blocks 2724A-2724N and the tensor accelerator 2723,including but not limited to a set of registers 2725, a power andperformance module 2726, and a cache 2727. In one embodiment theregisters 2725 include directly and indirectly accessible registers,where the indirectly accessible registers are optimized for use by thetensor accelerator 2723. The power and performance module 2726 can beconfigured to adjust power delivery and clock frequencies for thecompute blocks 2724A-2724N to power gate idle components within thecompute blocks 2724A-2724N. In various embodiments the cache 2727 caninclude an instruction cache and/or a lower-level data cache.

The GPGPU 2720 can additionally include an L3 data cache 2730, which canbe used to cache data accessed from the unified memory 2710 by thetensor accelerator 2723 and/or the compute elements within the computeblocks 2724A-2724N. In one embodiment the L3 data cache 2730 includesshared local memory 2732 that can be shared by the compute elementswithin the compute blocks 2724A-2724N and the tensor accelerator 2723.

In one embodiment the GPGPU 2720 includes instruction handling logic,such as a fetch and decode unit 2721 and a scheduler controller 2722.The fetch and decode unit 2721 includes a fetch unit and decode unit tofetch and decode instructions for execution by one or more of thecompute blocks 2724A-2724N or the tensor accelerator 2723. Theinstructions can be scheduled to the appropriate functional unit withinthe compute block 2724A-2724N or the tensor accelerator via thescheduler controller 2722. In one embodiment the scheduler controller2722 is an ASIC configurable to perform advanced scheduling operations.In one embodiment the scheduler controller 2722 is a micro-controller ora low energy-per-instruction processing core capable of executingscheduler instructions loaded from a firmware module.

In one embodiment some functions to be performed by the compute blocks2724A-2724N can be directly scheduled to or offloaded to the tensoraccelerator 2723. In various embodiments the tensor accelerator 2723includes processing element logic configured to efficiently performmatrix compute operations, such as multiply and add operations and dotproduct operations used by 3D graphics or compute shader programs. Inone embodiment the tensor accelerator 2723 can be configured toaccelerate operations used by machine learning frameworks. In oneembodiment the tensor accelerator 2723 is an application specificintegrated circuit explicitly configured to perform a specific set ofparallel matrix multiplication and/or addition operations. In oneembodiment the tensor accelerator 2723 is a field programmable gatearray (FPGA) that provides fixed function logic that can updated betweenworkloads. In one embodiment, the set of compute operations that can beperformed by the tensor accelerator 2723 may be limited relative to theoperations that can be performed by the compute block 2724A-2724N.However, the tensor accelerator 2723 can perform parallel tensoroperations at a significantly higher throughput relative to the computeblock 2724A-2724N.

FIG. 28A-28B illustrate a matrix operation 2805 performed by aninstruction pipeline 2800, according to embodiments. FIG. 28Aillustrates the instruction pipeline 2800 when configured with asystolic array 2808 within the tensor accelerator 2723. FIG. 28Billustrates the instruction pipeline when configured with an executionunit 1900 that includes a systolic array 1912.

As shown in FIG. 28A, the instruction pipeline 2800 can be configured toperform a matrix operation 2805, such as, but not limited to a dotproduct operation. The dot product of two vectors is a scalar value thatis equal to sum of products of corresponding components of the vectors.The dot product can be calculated as shown in equation (1) below.

$\begin{matrix}{{\overset{\rightarrow}{a} \cdot \overset{\rightarrow}{b}} = {{\sum\limits_{i = 1}^{n}{a_{i}b_{i}}} = {{a_{1}b_{1}} + \ldots + {a_{n}b_{n}}}}} & (1)\end{matrix}$

The dot product can be used in a convolution operation for aconvolutional neural network (CNN). While 2D convolution is illustrated,N-dimensional convolution can be performed on an N-dimensional volumeusing N-dimensional filters. A receptive field tile 2802 highlights aportion of an input volume in an input volume buffer 2804. The inputvolume buffer can be stored in memory 2830. A dot product matrixoperation 2805 can be performed between the data within the receptivefield tile 2802 and a convolutional filter to generate a data pointwithin output buffer 2806, which can also be stored in memory 2830. Thememory 2830 can be any of the memory described herein, including systemmemory 2712, GPGPU memory 2718, or one or more cache memories 2727, 2730as in FIG. 27 .

The combination of the data points within the output buffer 2806represents an activation map generated by the convolution operation.Each point within the activation map is generated by sliding thereceptive field tile across the input volume buffer 2804. The activationmap data can be input to an activation function to determine an outputactivation value. In one embodiment, convolution of the input volumebuffer 2804 can be defined within a framework as high-level matrixoperation 2805. The high-level matrix operations can be performed viaprimitive operations, such as a basic linear algebra subprogram (BLAS)operation. The primitive operations can be accelerated via hardwareinstructions executed by the instruction pipeline 2800.

The instruction pipeline 2800 used to accelerate hardware instructionscan include the instruction fetch and decode unit 2721, which can fetchand decode hardware instructions, and the scheduler controller 2722which can schedule decoded instructions to one or more processingresources within the compute blocks 2724A-2724N and/or the tensoraccelerator 2723. In one embodiment, a hardware instruction can bescheduled to the compute blocks 2724A-2724N and offloaded to the tensoraccelerator 2723. The one or more hardware instructions and associateddata to perform the matrix operation 2805 can be stored in the memory2830. Output of the hardware instruction can also be stored in thememory 2830.

In one embodiment, the tensor accelerator 2723 can execute one or morehardware instructions to perform the matrix operation 2805 using asystolic array 2808 of processing elements. The systolic array 2808includes a combination of programmable and fixed function hardware thatis configurable to perform matrix-matrix and matrix-vector dot productoperations, as well as other operations, such as matrix-matrix andmatrix-vector fused multiply-add operations.

In various embodiment, as an alternative or in addition to the tensoraccelerator 2723, matrix acceleration logic can also be included withinthe processing resources of the compute blocks 2724A-2724N. For example,as shown in FIG. 28B, in one embodiment each compute block (e.g.,compute block 2724N) includes an array of execution units 1900A-1900N.In one embodiment, each execution unit in the array of execution units1900A-1900N can include systolic arrays 1912A-1912N. In one embodiment,one or more of a subset of the execution units is configured with asystolic array. The number of systolic arrays and the throughput of theavailable systolic arrays can vary based on the power and performancetargets for a device. The scheduler controller 2722 can schedulesystolic matrix operations (dot products, fused multiply-adds, etc.) toavailable systolic arrays 1912A-1912N within the execution units1900A-1900N of the various compute blocks 2724A-2724N.

While in one embodiment each of the compute blocks 2724A-2724N includean array of execution units 1900A-1900N, in another embodiment thecompute blocks 2724A-2724N share an architecture with the processingclusters 214A-214N of the processing cluster array in FIG. 2A. In suchembodiment, the compute blocks 2724A-2724N include multiple graphicsmultiprocessors 234 as in FIG. 2C, which include internal components asillustrated in FIG. 2D. Thus, the graphics multiprocessors within thecompute blocks can include a load/store unit 266, GPGPU cores 262, andtensor/RT cores 263. In one embodiment the compute blocks 2724A-2724Ncan include multi-core group 365A-365N of the GPU 380 of FIG. 3C andinclude multiple sets of GFX cores 370, tensor cores 371, and raytracing cores 372. In such embodiment, the scheduler controller 2722 canschedule instructions to perform matrix operations to the tensor/RTcores 263 and/or tensor cores 371 within the compute blocks 2724A-2724N.Accelerated matrix operations include dot product operations, matrixmultiply operations, and/or fused multiply-add operations, which can beperformed on integer or floating-point matrix elements and variouslevels of precision. Additionally, in one embodiment the compute blocks2724A-2724N can include a variant of the compute units 1560A-1560N ofFIG. 15C, where such variants include matrix acceleration logic asdescribed herein (e.g., systolic array, tensor core, systolic tensorcore) that can execute integer or floating-point matrix accelerationinstructions.

FIG. 29 illustrates a systolic array 2900 including multiplier and addercircuits organized in a pipelined fashion. In one embodiment, systolicarray 2900 is representative of the physical pipeline stages included inthe systolic array 1912 and includes capabilities described in relationto that systolic array 1912, including support for sparse and blocksparse operations, and may additionally be configured to supportstructured sparsity within a vector of elements or across a set ofchannels. Inputs 2912A-2912H for the first input matrix are representedby the data elements contained in the inputs labeled Src1 and Src1+1through Src1+7. Inputs 2910A-2910H correspond to the second input matrixand are labeled as Src2. Inputs 2902A-2902B, which may include initialaccumulator values, can be provided as Src0. An array of processingelements make up the physical pipeline stages 2911A-2911H of thesystolic array 2900. Matrix-Matrix or Matrix-Vector operations,including fused multiply-add and/or dot product operations, can beperformed at each pipeline stage 2911A-2911H during each clock cycle. Oneach cycle, every pipeline stage can receive a new Src2 input can beused by the processing elements of the pipeline stage to compute a valueusing either the new Src1 input or an older Src1 input that waspreviously read, although during initial startup it may take severalcycles before all of the pipeline stages 2911A-2911H become active asthe initial set of computed values propagate through the stages.

Input 2902A can provide a Src0 value to processing element of pipelinestage 2911A, for use as an initial accumulator value. Alternatively,input 2902B can provide the Src0 value to be added to the valuescomputed by pipeline stage 2911H of the systolic array, which enablespartial pass operation for systolic array 2900 using the lower stages ofthe array while the unused upper stages are power gated. Duringoperation, the data elements of a selected channel of the Src2 input arebroadcast across all channels of the processing elements of the pipelinestages 2911A-2911H, where each channel represents a vector of multipleelements. The number of elements per channel can vary based on the sizeof the elements. The processing elements of a stage then performoperations using the selected Src2 channel and all channels of a givenSrc1 input. A Src2 input operates with eight Src1 inputs (e.g., one Src1input per stage). The data elements of a channel of the Src2 input arebroadcast across all channels of processing elements 2911A-2911H. Theprocessing elements then operate the Src2 channel with all channels of aSrc1 input. In a first clock cycle, a Src1 input is operated with dataelements of the first channel of Src2. In the next cycle, a second Src1(labeled as Src1+1) operates with the data elements of the secondchannel of Src2. This sequence repeats on the eight stages of thepipeline. Each stage adds its operation to the output of the previousstage. Across the pipeline stages, multiple Src2 inputs are operated ina pipelined fashion. As successive channels of a first Src2 input arepushed through the pipeline stages, a new Src2 input can be provided atthe first stage.

Output 2922 from the final stage is labeled as Dst. Where d=the systolicdepth and e=the number of data elements per channel, the output of achannel is described by equation (2) below:

$\begin{matrix}{{Dst}_{i} = {{{Src}0_{i}} + {\sum\limits_{j = 0}^{d}{\sum\limits_{k = 0}^{e}{\left( {{{Src}1} + j} \right)_{{element}k{of}{channel}i}*{Src}2_{{element}k{of}{channel}j}}}}}} & (2)\end{matrix}$

As shown in equation (2), each channel can include multiple dataelements on which operations are performed in parallel. In oneembodiment, each channel represents a four element data vector, althougha different number of elements can be configured for each channel. Inone embodiment, the number of data elements within a channel can varybased on the size of each data element. Dot products can be performedusing, for example, four element vectors with 8-bit data types perelement, two element vectors with 16-bit data types, eight elementvectors with 4-bit data types (e.g., INT4), or 16 element vectors with2-bit data types (e.g., INT2). The number of channels can beautomatically adjusted depending on the datatype of Src1 and Src2. Aninstruction can also specify a required systolic depth to be used forthe instruction.

In one embodiment the processing elements 2911A-2911H may read inputs2910A-2910H, 2912A-2912H directly from the general-purpose registerfile. In one embodiment systolic array 2900 includes logic to readinputs 2910A-2910H, 2912A-2912H from the general-purpose register fileand store input data in registers, buffers, or memory that is internalto the systolic array. Internal logic can then feed the input dataelements to the processing elements 2911A-2911H for processing. Output2922 can be written to internal registers or memory of the systolicarray 2900 and/or written directly to the general-purpose register file.

FIG. 30A-30B illustrates the use of a systolic array 3000 that can beconfigured to execute operations at an arbitrary systolic depth. In theillustrated example, the systolic array 3000 has a physical depth offour, which corresponds with four physical pipeline stages. The systolicarray can be configured to operate using an arbitrary number of logicalstages, including four, eight, twelve, or sixteen logical stages, orother numbers of logical stages that are not divisible by the number ofphysical stages using partial-pass operations as in FIG. 31 describedbelow. FIG. 30A shows the array receiving Src0 inputs from an externalsource and processing the first four stages with Src1 and Src2 inputs.The output of this array is fed back into the second step shown in FIG.30B. FIG. 30B shows that the next four stages are calculated using theloopback data that includes the already processed values and the Src1and Src2 inputs.

As shown in FIG. 30A, systolic array 3000 can accept input 2902, as Src0input, which is read (3002) via data selector 3004. Data selector 3004selects between the input 2902 and loopback input 3006. Processingelements 2911A-2911D can process inputs 2910A-2910D and 2912A-2912D in asimilar manner as systolic array 2900. If four stages are sufficient tocomplete an operation, pipeline stage 2911D can write (3022) output 2922to a specified Dst register or memory via data selector 3024. Wherefurther stages are required, data selector 3024 can write loopbackoutput 3026, which is provided as loopback input 3006 to processingelements of pipeline stage 2911A.

As shown in FIG. 30B, in one embodiment, loopback input 3006 can befurther processed by processing elements 2911A-2911D. Loopback input3006 includes the already processed values. In one embodiment, loopbackinput 3006 can also include input 2910E-2910H, input 2912E-2912H, whichcan be pre-fetched while processing the first four stages. Data selector3004 select loopback input 3006 for input by pipeline stage 2911A.Processing elements of the pipeline stages 2911A-2911D can then processinputs 2910E-2910H and 2912E-2912H. Data selector 3024 can then write(3022) the eighth stage result as output 2922 to the specified Dstregister.

In one embodiment, the systolic array 3000 is modified to exclude theloopback output 3026 and loopback input 3006 and instead includeintermediate storage 3025, as shown in FIG. 30A-30B. The intermediatestorage 3025 may be a memory device or register that is internal to thesystolic array 3000 or may be a register in a register file that isexternal to the systolic array 3000. During the operations shown in FIG.30A, output from pipeline stage 2911D can be stored in the intermediatestorage 3025 instead of being output by loopback output 3026 and read byloopback input 3006 before the operations shown in FIG. 30B. During theoperations shown in FIG. 30B, output from pipeline stage 2911D can beadded to the data stored in the intermediate storage 3025 and written tooutput 2922. The systolic array 3000 can also be configured to performmulti-pass operations using at least one partial pass, as describedbelow, to enable logical depths that are not divisible by the physicaldepth of the array.

Scalable Matrix Multiply Accelerator with Feedback Inputs

A second embodiment enables increased throughput using simultaneousinstructions executed using parallel units. Several instances or pathsof the multiply accelerator are run in parallel. These instances canshare Src1, or they can have independent Src1 inputs. Each path willhave their own Src2 and Src0 inputs. These instances will have their ownsrc2 and src0 inputs. A version showing two paths with a depth of fourstages is shown in FIG. 31 . Alternatively, a version using four pathsof depth of two stages is shown in FIG. 32 .

FIG. 31 illustrates a two-path matrix multiply accelerator 3100 in whicheach path has a depth of four stages. The two-path matrix multiplyaccelerator 3100 includes input logic 3102A-3102B for Src0 inputs, inputbuffers 3111A-3111B to store data elements received from input logic3110A-3110B, and input buffers 3113A-3113B to store data elementsreceived from shared input logic 3112 for Src1. Each stage includes apair of processing elements, which may operate in parallel. Stage oneincludes processing elements 3131A-3131B, stage two includes processingelements 3132A-3132B, stage three includes processing elements3133A-3133B, stage four includes processing elements 3134A-3134B.Hardware logic of each of the processing elements 3131A-3131B,3132A-3132B, 3131A-3133B, 3134A-3134B can be the same as or similar tothe hardware logic of processing elements of systolic array 2900 orsystolic array 3000 and may be manufactured with the same processtechnology or a more advanced process technology. The processingelements of the two-path matrix multiply accelerator 3100 may alsooperate at a higher frequency relative to implementations of systolicarray 2900. The processing elements and may be manufactured using moreadvanced process technology.

Feedback may be implemented using data selectors that are the same as orsimilar to data selectors 3004, 3024. Depending on the configuration ofthe read logic, input data can be pre-fetched into the input buffer inadvance or read from registers or a cache within the two-path matrixmultiply accelerator 3100 one or more cycles before input into theprocessing elements 3131A-3131B. Processing elements 3134A-3134B ofstage four can feed back into the corresponding processing elements3131A-3131B stage one. Dynamic logical depth may be enabled in multiplesof four. After a configured number of logical stages, results may bewritten by output logic 3122A-3122B to a specified destination.

FIG. 32 illustrates a four-path matrix multiply accelerator 3200 inwhich each path has a depth of two stages. Four-path matrix multiplyaccelerator 3200 includes the same number of processing elements astwo-path matrix multiply accelerator 3100, with the processing elementsconfigured with twice as many paths, but each path is half as deep.Four-path matrix multiply accelerator 3200 includes input logic3202A-3202D for Src0, input buffers 3211A-3211D to store input elementsread by input logic 3210A-3210D for Src2, and input buffers 3213A-3213Dto store input elements read by shared input logic 3212 for Src1.Processing elements 3231A-3231B enable parallel processing for stage 1.Processing elements 3232A-3232B enable parallel processing for stage 2.Stage 2 of each path can feed back into stage 1 or write results viaoutput logic 3222A-3222D to a specified destination. Processing elements3231A-3231B, 3232A-3232B may include hardware logic similar to that ofprocessing elements 3131A-3131B, 3132A-3132B, 3131A-3133B, 3134A-3134Band can implement loopback functionality using similar hardware logic.

The advantages of a two-path matrix multiply accelerator 3100 or afour-path matrix multiply accelerator 3200 include scalability, softwarecompatibility, and throughput. The modular architecture of theseaccelerators enables more efficient scaling relative to an 8-deepsystolic array. Different configurations of a matrix multiplyaccelerator can be tailored for different product needs or use caseswithout redesign. Additionally, the same software model that is used isindependent of the hardware implementation. Algorithms designed for aninstruction intended to be executed by a systolic pipeline of eightstages can be used in an implementation using a Matrix Multiplyaccelerator of four stages. Hardware will use feedback to simulate apipeline of eight stages in a way that is transparent to the software.Multiple paths can be used in a design requiring high DPAS instructionthroughput. Implementations with a greater number of paths can becoupled with higher bandwidth input logic and output logic. In oneembodiment, the two-path matrix multiply accelerator 3100 and afour-path matrix multiply accelerator 3200 are configured to bypassinputs with block sparsity at a greater efficiency and/or finergranularity than possible with an 8-deep systolic array.

Sparse Multiplications on the Scalable Matrix Multiply Accelerator

A third embodiment facilitates increased instruction throughput whenprocessing for data with irregular sparsity. Elements of Src1 and Src2inputs can be individually selected via input multiplexer logic andprocessing can be performed using only non-zero values.

FIG. 33 illustrates a scalable sparse matrix multiply accelerator 3300using systolic arrays with feedback inputs. Scalable sparse matrixmultiply accelerator 3300 can include processing elements 3231A-3231D asin four-path matrix multiply accelerator 3200, or any other processingelements described herein. Processing elements 3231A-3221B at thebeginning of each path include input logic for Src0. Each stage of eachpath of scalable sparse matrix multiply accelerator 3300 can receive anyelement of an independent or shared Src1 via input selectors3312A-3312D. Each stage of each path can also receive any element of aSrc2. Independent Src2 inputs are provided via separate input elementselectors (e.g., Src2A via input selector 3310A and input selector3311A, Src2B via input selector 3310B and input selector 3311B). Theseparate Src2 input enables the separate paths to compute differentinstructions. Separate output logic 3322A-3322B is present for each pathto enable output for the different instructions.

FIG. 34 shows a scalable sparse matrix multiply accelerator 3400 usingsystolic arrays with feedback inputs and outputs on each stage. Scalablesparse matrix multiply accelerator 3400 includes similar hardware logicas scalable sparse matrix multiply accelerator 3300, along withadditional input and output logic to enable Src0 elements to be providedto each stage of each path and to provide separate outputs for eachstage of each path. In addition to input selectors 3310A and 3311A toselect Src2A elements for the first path and input selectors 3310A and3311B to select Src2B input for the second path, an input splitter3403A-3403B is added for each path for Src0 input. Each input splitter340A-3402B can include a demultiplexer or similar hardware logic toenable Src0 input elements that are read by input logic 3402A-3402B tobe sent to each stage. Input selectors 3312A-3312D are also included toenable Src1 input to be elected by each stage of each path. In additionto output logic 3322A-3322B from the second stage of each path(processing element 3431C-3431D), additional output logic 3422A-3422B isprovided to enable output from the first stage of each path(3431A-3431B). The processing elements 3431A-3431C may be otherwisesimilar to other processing elements described herein.

During operation, scalable sparse matrix multiply accelerator 3400 isconfigurable to accept groups of only one element. Given Src2 input {B0,0, B2, B3, 0, 0, 0, 0}, two groups ([B0,B2], [B3,0]) are made for thenon-zero elements on Src2 for the third embodiment (e.g., scalablesparse matrix multiply accelerator 3300), with the second groupincluding a zero padding. The optimizations shown in FIG. 34 enable thegroups to be formed as [B0,B2], [B3]. B0 and B2 will be assigned to thefirst and second stage of a path (e.g., either of a first set includingof processing element 3431A and processing element 3431C or a second setincluding processing element 3431B and processing element 3431D). Afterthe feedback, B3 will be assigned to the first stage of that path. Asthe first stage of a path can provide output (e.g., via either outputlogic 3422A or 3422B), there is no need to consume the second stage ofthe path (either of processing element 3431C or processing element3431D). Moreover, the next Src2 input accepted for that path can startfrom the second stage, so a group of two elements will be assigned tothe second and first stage, respectively. Src0 for processing the newSrc2 input can be assigned to the second stage of the path (e.g., viaeither output logic 3422A or 3422B)

In addition to the hardware logic of scalable sparse matrix multiplyaccelerator 3300 illustrated in FIG. 33 and scalable sparse matrixmultiply accelerator 3400 illustrated FIG. 34 , some embodimentsadditionally include input and output hardware memory buffers. Inputmemory buffers can be used to store and have ready groups of Src0 andSrc2 inputs, which reduces the need for high bandwidth input logic. Theoutput buffer allows Dst outputs generated in a same cycle to besteadily written to memory at a slower rate, which reduces the need forhigh bandwidth output logic.

Additionally, some embodiments include a bypass for inputs in which allelements are zero. The bypass allows a direct write of Src0 as by outputlogic without passing through the systolic array. This bypass is used inconcert with a data dependency strategy to prevent read-after-write(RAW) risks among instructions can damage the integrity of the data.

Matrix Accelerator Having a Dual Pipeline Parallel Systolic Array

FIG. 35 illustrates a dual pipeline parallel systolic array 3500 for amatrix accelerator, according to an embodiment. A matrix accelerator asdescribed herein (e.g., tensor accelerator 2723, tensor/RT cores 263,tensor cores 371), or execution unit (e.g., execution unit 1900) caninclude a dual pipeline parallel systolic array 3500 that includes twosystolic array pipelines (systolic pipeline 3502, systolic pipeline3504) that operate in parallel to execute instructions. The dualpipeline parallel systolic array 3500 enables the row data that isprovided as Src2 input to be partitioned, with the partitions beingprocessed in parallel using a common Src1 input. Such configurationenables increased throughput for matrix operations without incurring thepower and area costs associated with two separate and fully independentsystolic arrays.

Input for matrix operations can be read from a register file (e.g.,register file(s) 258, 334A-334B, 369, vector registers 1561, GRF 1821,register file 1906, etc.) that is associated with the matrixaccelerator. The dual pipeline parallel systolic array 3500 includes aninput 3521 for a Src1 operand that is shared between the two systolicarray pipelines. The Src1 input inputs column data that is used by thetwo systolic array pipelines to perform matrix multiply operations inwhich two sets of matrix row data (Src2 input 3522A-3522B) aremultiplied by a single set of column data. A single Src2 register canstore input for two stages of operation. For example, data from inputs3522A-3522B can be read in 64-bit blocks, with the lower 32-bits beingused for operations at a stage of the systolic array and the upper32-bits being used for operations at the next successive stage of thesystolic array. As one Src2 read can be used for two operations on anarray, the second cycle of a pair of Src2 read cycles can be used toread a new Src2 for the second array. The common input 3521 for Src1data and the use of Src2 register data for multiple operations reducesread demand on the GRF relative to two fully independent systolicarrays. The reduce register read demand relative to the use ofindependent systolic arrays can reduce the potential negative impact onperformance caused for other processing elements that share the registerfile with the systolic array when those processing elements areoperating concurrently with the systolic arrays.

Separate inputs 3520A-3520B are provided for Src0 (accumulator value)inputs. The data from inputs 3520A-2020B is stored in a Src0 data buffer3530A-3530B and added to output from the systolic array pipelines, asopposed to being added at Stage 0 as in other systolic array designs.Output from each array can be stored in accumulator/adder circuits thatinclude memory (e.g., an accumulator register) and an adder circuit.Accumulator/adder circuit 3532 can store output from systolic pipeline3502 and add the output to data stored in Src0 data buffer 3530A.Accumulator/adder circuit 3534 can store output from systolic pipeline3504 and add the output to data stored in Src0 data buffer 3530B.

In one embodiment, multi-pass operation is enabled, such that the eightphysical stages of the array operate as sixteen logical states. Theeight stages of each of systolic pipeline 3502 and systolic pipeline3504 can operate as sixteen logical stages by respectively storing theoutput of a first pass to the first accumulator/adder circuit 3532 andsecond accumulator/adder circuit 3534. The values stored in the circuitscan be accumulated with output generated by a second pass through eachof systolic pipeline 3502 and systolic pipeline 3504. For a given stagei, the stage operates as stage i during a first pass and stage i+8during a second pass. The appropriate input data is provided to thearrays depending on whether the array is performing first passoperations or second pass operation. In one embodiment, operations forinstructions of any number of logical stages may be supported via singlepass and/or multiple or partial pass operation. A selector circuit 3536enables data within the first accumulator/adder circuit 3532 and secondaccumulator/adder circuit 3534 to be output to a destination register.

FIG. 36 illustrates a stage pair 3600 for a channel of a systolic array.In one embodiment the physical pipeline stages for each array of thedual pipeline parallel systolic array 3500 of FIG. 35 are grouped as astage pair 3600. A stage pair 3600 for Stage 0 (3610) and Stage 1 (3611)is illustrated, with other pairs of stages (e.g., [2,3], [4,5], [6,7])being configured similarly. Each channel of each stage includes a pairof multipliers (e.g., multipliers 3612A-3612B for Stage 0, multipliers3613A-3613B for Stage 1) and a common adder 3604. The accumulator input3620 (Src0) is passed through to Src0 data buffer 3530A-3530B shown inFIG. 35 and is not operated on by the stage pair 3600. The appropriateSrc1 register data is provided as input to the appropriate stage. Asingle Src2 register read can store data for both stages in the stagepair 3600.

FIG. 37 illustrates a systolic array 3700 including partial sum loopbackand circuitry to accelerate sparse matrix multiply. In the systolicarray 2808 described above, operands that include weight data may bestationary within the array and a partial sum is propagated throughoutthe array structure. While other details with respect to systolic array2808 may be applicable, in systolic array 3700 a partial sum isrecirculated instead of being propagated to a next systolic layer. Inone embodiment a systolic array 3700 can be configured with M rows and Ncolumns of processing elements (PE 3712AA-PE 3712MN). The processingelements can access registers storing input data in the form of row andcolumn data for input matrices. The registers may be stored in aregister file that is local to the systolic array 3700 or in a registerfile of a processing resource that is coupled with or includes thesystolic array 3700. The registers may store row elements of matrix A3702A-3702M, which are to be multiplied by column elements of matrix B3701A-3702N.

In one embodiment a fused multiply-add (FMA) can be performed at eachprocessing element PE 3712AA-PE 3712MN each clock cycle. An element ofmatrix A is multiplied by a corresponding element of matrix B and thenadded to an accumulator value or, for the first cycle, an optionalinitial input value (e.g., SRC0). Partial sum loopback can be configuredat each processing element. After each cycle, the accumulator value maybe looped back within the processing element and used as input for thenext cycle. Once operations are performed for an entire row, the resultmay be stored to a register file. Data movement between the processingelements PE 3712AA-PE 3712MN after a set of computational cycles canvary based on the instruction or macro-operation being performed.

Data Aware Sparsity with Compression

Embodiments described herein provide an encoding layout that enablessample blocks of sparse neural network data to be encoded in areduced-bit formal that reduces the amount of data that is required tobe transmitted or stored when processing neural networks associated withthe data. The number of non-zero values in a sample block is indicatedin a header, followed by a significance map indicating a map of thenon-zero values within the block. The non-zero values of the sample areencoded in order of appearance within the stream. In one embodiment,compression can be based on other values beyond zero values. Forexample, a specified value within a data set may be encoded and excludedfrom a compressed data stream, enabling compression based on ones, twos,or other specified values. In one embodiment compression is enabledbased on near values. Values within a data set that are within athreshold of zero, or within a threshold of a specified value, may becompressed as though those values were zero or within a threshold of thespecified value. Data aware sparsity with compression can be enabled viacodec logic coupled with or within matrix accelerator logic.

FIG. 38A-38B illustrate matrix acceleration circuitry including codecsto enable the reading of sparse data in a compressed format. FIG. 38Aillustrates a compute block 3800 including codec enabled disaggregatedsystolic logic. FIG. 38B illustrates processing elements within asystolic array that are coupled with codecs to decompress input data.

As shown in FIG. 38A, instead of including a systolic array 2808 in aseparate tensor accelerator 2723, as in FIG. 28A, or including asystolic array 1912 in each execution unit 1900 as in FIG. 19 , adisaggregated set of systolic arrays 3812A-3812B can be included in acompute block 3800 that is analogous to one of the compute blocks2724A-2724N of FIG. 27 . The compute block 3800 can also includecomponents of execution logic 1800 of FIG. 18A, including multipleinterconnected processing resources (PR 3808A-3808O) that may be similarto EU 1808A-1808N or any other processing resource as described herein.In one embodiment the systolic arrays 3812A-3812B include codecs3824A-3824B that enable the encoding and decoding of input and outputdata that is received for processing.

The systolic arrays 3812A-3812B include a W wide and D deep network ofdata processing units that can be used to perform vector or otherdata-parallel operations in a systolic manner, similar to other systolicarrays described herein. In one embodiment the systolic arrays3812A-3812B can be configured to perform matrix operations, such asmatrix dot product operations. In one embodiment the systolic arrays3812A-3812B support 16-bit floating point operations, as well as 8-bitand 4-bit integer operations. In one embodiment the systolic arrays3812A-3812B can be configured to accelerate machine learning operations.In such embodiments, the systolic arrays 3812A-3812B can be configuredwith support for the bfloat 16-bit floating point format. By includingsystolic arrays 3812A-3812B within the compute block 3800 but outside ofthe PRs 3808A-3808O, the size and number of systolic arrays 3812A-3812Bcan be scaled independently from the number of PRs 3808A-3808O.Additionally, communication bandwidth within an PR that would otherwisebe consumed by systolic array activity may be preserved. Furthermore,the systolic arrays 3812A-3812B may be clock/power gated when matrixworkloads are not being performed.

Communication between the systolic arrays 3812A-3812B and the PRs3808A-3808O may be performed via a cache or shared local memory(cache/SLM 3810) and/or a shared register file 3814. In one embodiment,instead of a distinct shared register file 3814, the cache/SLM 3810 maybe partitioned for use as a shared register file. The shared registerfile 3814 may be structured similarly to other GPGPU register files,such as register file 1906 as in FIG. 19 . The shared register file mayalso include a set of special purpose registers that are used toconfigure the interaction between the systolic arrays 3812A-3812B andthe PRs 3808A-3808O. The cache/SLM 3810 may be an L1 cache, an L2 cache,and/or a block of explicitly addressable on-die memory.

Matrix data for processing by the systolic arrays 3812A-3812B may bestored in the cache/SLM 3810. Processing commands or instructions can beprovided to the systolic arrays 3812A-3812B via the shared register file3814. Processing results may be read from the cache/SLM 3810 by the PRs3808A-3808O or from destination/output registers within the sharedregister file. During operation, instead of consuming bus/fabricbandwidth within the PRs 3808A-3808O, communication traffic may belocalized to the systolic arrays 3812A-3812B, the cache/SLM 3810, and/orshared register file 3814. Any of the PRs 3808A-3808O within the computeblock 3800 may offload a matrix workload to one or both systolic arrays3812A-3812B. A message may be sent from a PR to a systolic array with acommand that specifies an operation to be performed and operands for theoperation. The systolic arrays 3812A-3812B can perform the requestedoperations (multiply/add, fused multiply/add, multiply/accumulate, dotproduct, etc.) and output the results to the shared register file 3814.Input, intermediate and/or output data for requested operations may bestored in the cache/SLM 3810 and multiple dependent operations may bechained. In one embodiment when processing operations for training orinference for a neural network are performed, the systolic arrays3828A-3828B may also perform activation functions including but notlimited to sigmoid, ReLU, and hyperbolic tangent (TanH) activations. Insuch embodiment, operations for neural networks may be offloaded to thesystolic arrays 3812A-3812B at coarse granularity.

The PRs 3808A-3808O can provide input data to the systolic arrays3812A-3812B in a compressed format and the codecs 3824A-3824B can beused to decompress the data. When output data is ready to be provided tothe PRs 3808A-3808O, the data may remain decompressed if the PRs willperform operations and the data and do not support the direct read ofcompressed data. If the PRs 3808A-3808O support the reading ofcompressed data or will not perform additional operations on the data,the output data may be re-encoded. Zero-based encoding may be used andcompression may be enabled or disabled based on the degree of datasparsity. Alternatively, other forms of encoding may be used based onthe distribution of the data set to be processed or output. For example,the codecs 3824A-3824B can be configured to decode sparse data that isencoded based on zero-based compression or using another form ofcompression described herein (e.g., one-based, two-based, near-zero,near-one, near-two, etc.).

As shown in FIG. 38B, system 3850 illustrates processing elements ofsystolic array 3700, where the systolic array is configured to decodecompressed sparse data. As described with respect to FIG. 37 , each PE3712AA-3713MN includes hardware logic to perform computations for matrixoperations. A (A0, A1, through A_(M)) and B (B0, B1, through B_(N)) areelements of input matrices with associated with dot product, matrixmultiply, multiply/add, or multiply accumulate operations. In oneembodiment each PE 3712AA-3713MN is associated with codecs (3851 a, 3851b, . . . , 3851 m; 3852 a, 3852 b, . . . , 3852 n) to decode compressedinput operands associated with operations to be performed. The codecscan be configured to decode sparse data that is encoded based onzero-based compression or using another form of compression describedherein.

Sparse neural network data can be encoded (e.g., compressed) using avariety of encoding techniques, such as but not limited to uniqueabsolute value (UAV) table encoding, significance map (SM) encoding,table encoding (TE), unique value coordinate (UVC) encoding, and meanencoding (ME). Metadata for the encoded data indicates the type ofencoding format used for the data. In one embodiment, specific encodingformats can be selected for specific types of data, such as kernel dataor feature data. In one embodiment, statistical analysis is performed onthe data prior to encoding to enable an appropriate encoder to beselected for each block of data. The encoding may be zero-basedencoding, near-zero encoding or based on other values (ones, twos,etc.).

In one embodiment data generated during SM encoding can be used tofacilitate provision of compressed data to a systolic tensor array. Inzero-based SM encoding mode, only non-zero values in a block areencoded. The number of non-zero values in a sample block is indicated inthe header, followed by a significance map indicating a map of thenon-zero values within the block. The non-zero values of the sample arethen encoded in order of appearance within the stream.

Temporally Amortized Supersampling Using Mixed Precision ConvolutionalNeural Network

Described herein are embodiments that provide a machine learning-basedtemporally amortized supersampling technique that replaces temporalanti-aliasing (TAA). A mixed low precision convolutional neural networkis used that applied different computational precisions at differentstages to enable the high performance generation of high quality imagesbased on source images rendered at a relatively lower resolution thanthe target output resolution. The network model enables anti-aliasingand upscaling with support for multiple scale factors, includingfractional scale factors such as, but not limited to 1.3×, 1.5×, 1.7×,2×, or 2.2×. Other scale factors are also possible. Temporally stableupscaled output can be generated that has an image quality that isbetter than or equal to native rendering at the target resolution. Invarious embodiments, different versions are provided that can beimplemented on a variety of different graphics processing architectures,including architectures with matrix acceleration hardware as describedabove in FIG. 28A through FIG. 34 , as well as graphics processorarchitectures that lack dedicated matrix acceleration hardware.

FIG. 39 illustrates a conventional renderer 3900 with TemporalAnti-aliasing (TAA). The renderer within the rasterization and lightingstage 3910 can jitter (3905) the camera 3902 during rendering for everyframe to sample different coordinates in screen space 3904. Differentpixels can be sampled from different frames over time. The TAA stage3916 accumulates these samples temporally to produce a supersampledimage. A warping operation 3924 is applied to the previously accumulatedframe (History 3923) using renderer generated velocity/motion vectors3922 to align the previously accumulated frame with the current frame3912 (frame N) before accumulation. Optional upscaling 3914 can beperformed on the current frame before input to the TAA stage 3916, suchthat the current frame can be rendered at a lower resolution than thetarget resolution. The output frame can then be added to the history3923 for use in processing the next frame. Post processing operations3918 can then be performed at the upscaled target resolution. Whileapplying upscaling with TAA can improve rendering performance, theoutput images are of lower quality than images rendered natively at thetarget resolution. Some TAA implementations can use heuristics 3915 suchas but not limited to neighborhood color clamping, object identifiercomparisons, and depth value comparisons to detect mismatches betweencurrent and history frames and reject the history pixels. However, theseheuristics often fail and produce a noticeable amount of ghosting,over-blurring and/or flickering.

FIG. 40 illustrates a renderer 4000 that replaces the TAA stage with atemporally amortized supersampling stage, according to embodimentsprovided herein. Renderer 4000 differs from renderer 3900 of FIG. 39 inthat, in renderer 4000, temporally amortized supersampling is performedusing a mixed, low-precision convolutional neural network 4050 thatreplaces the TAA stage in the game renderer, achieving significantlybetter image quality than conventional TAA-based techniques, as well asproviding a performance boost by enabling rendering to be performed atlower resolution. The renderer 4000 can render the current frame 3912 ata lower than target resolution. An upscaling filter 4014 is applied tothe rendered image to upscale the image to the target resolution. In oneembodiment, the upscaling filter 4014 is applied by the renderer 4000before the current frame 3912 is provided to the supersampling stage. Inone embodiment, the upscaling filter is performed by the neural networkmodel 4050 during pre-processing operations. The upscaling filter 4014can include optimizations to enhance the image quality of temporalstability of images that result from the processing performed by theneural network model 4050. Warping operations 4024 on the history 3923can be performed by an input block of the neural network model 4050. Inone embodiment the history 3923 is a multi-frame history that includesdata from multiple previous frames.

The mixed, low-precision convolutional neural network is implemented viaa neural network model 4050 that consists of multiple convolutionlayers, as well as other operations that are performed at lowprecisions, such as INT8, mixed with operations performed at a higherprecision, such as FP16. The mix of precisions enable the network toachieve a fast computational speed while generating high quality outputimages. The lower precision values are not limited to INT8 and differentlow-precision data formats (e.g., INT4, binary, bipolar binary, ternary,etc.) can be used for variations. The majority of the neural networkmodel 4050 and the operations associated with the neural network modelare performed at the lower precision to enable high inferenceperformance. A computationally smaller part is performed at a relativelyhigher precision to preserve output quality. In addition to using FP16for higher precision operations, other floating-point precisions mayalso be used, such as FP8, BF16 or TF32. Additionally, the majority ofthe neural network model 4050 is also in a reduced spatial dimension toprovide fast inference performance by shuffling input pixels from thespatial (width, height) dimension to a depth or feature map channeldimension with no pixel information loss. The spatial dimension isshuffled back from the channel dimension during generating an outputimage.

Temporally amortized supersampling is performed by combining the currentframe and the previous output frame warped with the current motionvectors. The neural network model 4050 determines the manner in which tocombine the upscaled current frame 3912 and the history 3923. In variousembodiments, multiple different approaches are applied to preserveoutput quality. In one embodiment, high precision combining of theupscaled current frame 3912 and the history is performed using 1×1 or3×3 output convolution. In another embodiment, pixel prediction and highprecision filtering of the upscaled image is performed to generate ahigh-quality upscaled image. The neural network model 4050 is used togenerate input that is provided to the kernel prediction and filteringoperations.

During training of the neural network model 4050, both perceptual andtemporal loss functions are optimized to enhance both the image qualityand the temporal stability of the upsampling and anti-aliasing. In oneembodiment, generalized training is sufficient to enable high qualityoutput across a variety of games without requiring extensive per-game,per-upscale factor, or per-target resolution training.

FIG. 41 illustrates an implementation of a neural network model 4100,according to an embodiment. The neural network model 4100 is animplementation of the neural network model 4050 of FIG. 40 . In oneembodiment, the neural network model 4100 is composed of threecomponents: an input block 4108, a feature extraction network 4110, andan output block 4120. Lower precision (e.g., Integer) operations areused for the majority of the neural network model to achieve fastinference performance. Output of the neural network model is generatedusing higher precision (e.g., floating-point) operations to enable thegeneration of high-quality output images. For example, the encoders(encoder block 1 through encoder block N), bottleneck block, and decoderblocks (decoder block 1 through decoder block N) in the featureextraction network 4110 are executed with relatively lower precision(e.g., INT8) compared to the output block 4120, which is executed at arelatively higher precision (e.g., FP16). Utilizing lower precision inthe feature extraction network 4110 significantly reduces the complexityof computation and improves memory bandwidth for fast inferenceperformance. Utilizing higher precision in the output block 4120 enablesthe generation of output images having an image quality that is as goodas, or in some cases better than images that are natively rendered atthe target resolution. As noted above, other precisions or data types inaddition to INT8 and FP16 can be used, such as but not limited to INT4for lower precision operations and BF16 or TF32 for higher precisionoperations.

The input block 4108 receives, as input, history data 4102, velocitydata 4104, the current frame 4106, and a jitter offset 4107 for thecamera. The history data 4102 includes previously generated output. Thepreviously generated output includes at least the immediate previousframe (frame N−1), which is warped using the velocity data 4104 to alignthe frame with the current frame 4106 for temporal accumulation. Invarious embodiments, in addition to the previous frame, the history data4102 can also include one or more additional frames of previousgenerated output (e.g., frame N−2, etc.), which can also be provided asinput to the feature extraction network 4110. The jitter offset 4107 isthe camera offset that is applied to jitter the scene, with differentjitter values being used for successive frames. The jitter offset 4107,in one embodiment, is a sub-pixel offset. The input block generates bothlower and higher precision tensors. Lower precision tensors are providedto the feature extraction network 4110. Higher precision tensors areprovided to the output block 4120. Further details on the input block4108 are shown in FIG. 42 .

The feature extraction network 4110 is built upon a U-shaped networkarchitecture, such as, for example, the U-net architecture. The featureextraction network 4110 differs from the conventional U-net architecturein that the feature extraction network 4110 includes an asymmetricstructure in the encoder 4112 and decoder 4116. The encoder 4112 of thefeature extraction network 4110 includes a series of encoder blocks thatdownsample the spatial dimension of an input tensor while increasing thenumber of channels (depth or feature maps) until the production of alatent representation 4114 at a bottleneck block in the middle of thenetwork. The latent representation 4114 is the abstractmulti-dimensional space that encodes the meaningful features of theinput data. The decoder blocks of the decoder 4116 reverse this processby upsampling spatial dimension and decreasing the number of channels.The encoder blocks have a skip connection to a corresponding decoderblock, which enables high-frequency details to be relayed between theencoder 4112 and the decoder 4116. Output from encoder block 1 isprovided to decoder block 2 for to be processed in conjunction withoutput from decoder block 3. Output from encoder block 2 is provided toencoder block 3 to be processed in conjunction with output from theprevious decoder block in the network. The input for encoder block N isprovided to decoder block N. Decoder block 1, the final decoder block,receives input from the input block 4108 and decoder block 2. Thedecoder 4116, from decoder block 1, provides data to the output block4120 in either a higher precision format or a lower precision formatdepending on the implementation approach used for the output block 4120.Further details on the output block are shown in FIG. 43A and FIG. 43B.

FIG. 42 illustrates further details for the input block 4108 of theneural network model 4100, according to embodiments. The input block4108 receives input including history data 4102, velocity data 4104, thecurrent frame 4106, and the jitter offset 4107. The input block 4108includes a warping unit 4202 to warp the previous output within thehistory data 4102 using motion vectors within the velocity data 4104.The input block 4108 also include an upscaling unit 4203 to upscale thecurrent frame 4106. In one embodiment, the upscaling filter applied bythe upscaling unit 4203 is an adaptive filter that adjusts the upscalingbased on the jitter offset 4107. A space to channel/depth shuffle unit4204 shuffles pixels from the spatial dimension (width, height) to achannel (e.g., feature map) or depth dimension, which facilitates highperformance inferencing via reduction of numerical precision and spatialdimension during feature extraction. For example, for an input imagehaving (channel, height, width) pixels of data in the spatial dimension,the pixel data can be shuffled to

$\left( {{{channel} \times r^{2}},\frac{height}{r},\frac{width}{r}} \right),$

which reduces the spatial dimension in which the feature extraction isperformed, which improves the performance of the feature extractionnetwork 4110. The input block 4108 generates both lower precision (e.g.,INT8) and higher precision (e.g., FP16) tensors. The lower precisiontensors are provided as input to the feature extraction network 4110,while the higher precision tensors are passed to the output block 4120,4320A-4320B. The input block 4108 also include an optionalconvolution/activation layer 4206 that can be applied before data isoutput to the feature extraction network.

FIG. 43A-43B illustrates output block variants for the neural networkmodel, according to embodiments. FIG. 43A illustrates a decoder block4320 and a variant of the output block 4320A that is configured toperform direct generation of pixel data for the output image. FIG. 43Billustrates a decoder block 4320 and a variant of the output block 4320Bthat is configured as a kernel prediction network that applies kernelpixel prediction and filtering to generate the output image. In FIG.43A-43B, a decoder block 4320 (decoder block 1) is shown as an example.While each encoder block of the encoder 4112 includes a downsample blockand one or more convolution/activation layers that facilitate featureextraction, each decoder block of the decoder 4116 includes an upsampleblock 4322 to increase spatial dimension and one or moreconvolution/activation layer(s) 4324, 4326 to restore features. Decoderblock 1 receives data from decoder block 2 as well as skip connectiondata from the input block. For the output block 4320A-4320B, twodifferent approaches can be taken to preserve quality with higherprecision. One embodiment provides an output block 4320A, as shown inFIG. 43A, which configures the neural network 4100 to operate as adirect reconstruction network. One embodiment provides an output block4320B, as shown in FIG. 43B, which configures the neural network 4100 tooperate as a kernel prediction network.

For output block 4320A of FIG. 43A, data from the input block 4108 andthe feature extraction network 4110 is combined using a 1×1 or 3×3output convolution layer 4330 to directly generate data for the outputimage. The output convolution layer 4330 receives, as input, higherprecision (e.g., FP16) output from the convolution/activation layer(s)4326 of the final decoder block 4320, as well as higher precision inputfrom the input block 4108. Data generated by the output convolutionlayer 4330 is provided to the depth/channel to space shuffle unit 4332,which shuffles the data back into the spatial dimension to generate anoutput image 4340. The output image 4340 can be output via a display orfurther post-processed before output via the display.

For output block 4320B of FIG. 43B, kernel prediction and filtering areperformed. Instead of directly generating an output image, per-pixelkernel values (e.g., weights) are predicted by a kernel prediction layer4334. Lower precision (INT8) tensors are output by the decoder block4320 for use by the kernel prediction layer 4334, which uses the lowerprecision tensors in combination with the higher precision tensorsprovided by the input block 4108. The depth/channel to space shuffleunit 4332 shuffles frame data back into the spatial dimension togenerate an intermediate output image. The intermediate output image isthen filtered by the filter/blend layer 4346 using the per-pixel kernelvalues generated by the kernel prediction layer 4334 and blending withthe previous output using blend weights generated by the kernelprediction layer 4334. The filtered and blended image is then providedas the output image 4340.

FIG. 44 illustrates a method 4400 to perform temporally amortizedsupersampling. The method 4400 includes to receive, at an input block ofa neural network model described herein (e.g., neural network model4050), history data, velocity data, and current frame data (4402). Thehistory data includes one or more previously generated frames. Thevelocity data includes renderer generated motion vectors that are usedto align the one or more previously generated frames with the pixel dataof the current frame. The current frame data includes a frame of a 3Dgraphics program, such as a 3D game application, that is output by araster and lighting stage of the render pipeline of the graphicsprocessor. In one embodiment, the current frame is an upscaled framethat has been upscaled by an upscaling filter from an initial renderingresolution to a target resolution. In one embodiment, the current frameis upscaled to the target resolution during pre-processing. The inputblock provides output at multiple precisions, with a first set of outputbeing provided to the output block at high precision and a second set ofoutput being provided to the feature extraction network at a relativelylower precision. In one embodiment, the first set of output is providedas floating-point data (e.g., FP16, BF16), while the second set ofoutput is provided as integer data (e.g., INT4, INT8).

The neural network model can then pre-process the history data, velocitydata, and current frame data at the input block and provide thepre-processed data to a feature extraction network (4404). Thepre-processed data that is provided to the feature extraction networkincludes aligned history data and current frame data. The history datais warped using the velocity data to generate warped history data. Thewarped history data is then aligned with the current frame data togenerate aligned history data. The aligned history data providesadditional sample data that can be used to generate a supersampledanti-aliased output image via temporal accumulation. In one embodiment,the pre-processing includes upscaling the current frame data from theresolution output by the raster and lighting stage to the targetresolution.

The neural network model processes the pre-processed data at the featureextraction network via one or more encoder stages and one or moredecoder stages (4406). The encoder stages reduce the spatial resolutionof the input data and extracts the most salient features within theinput data. The spatial resolution is then expanded via the decoderstages to generate tensor data that is used to process the currentupscaled frame in view of the aligned history to generate a high qualityupscaled frame that has an image quality that is, at the least, equal toan image that is natively rendered at the target resolution. Thefeatures extracted are used to determine an optimized combination of thecurrent and previous frames during temporal accumulation.

The neural network model can then generate an output frame via an outputblock of the neural network model via temporal accumulation using directreconstruction or kernel prediction (4408). The output frame is ananti-aliased image that has a higher resolution than the renderingresolution of the render pipeline, with additionally generated pixels toenhance the image quality beyond that of the originally upscaled image.In one embodiment, the neural network model is configured as a directreconstruction network which, via one or more convolution layers,generates a high-quality output image for display. When configured as adirect reconstruction network, the feature extraction network provideshigher precision tensors (e.g., FP16, BF16) as input to the outputblock. The output block uses the higher precision output from thefeature extraction network in combination with the higher precisionoutput from the input block to generate the output image. In oneembodiment, the neural network model is configured as a kernelprediction network that generates per-pixel kernel values that appliedto a high-precision filter. When configured as a kernel predictionnetwork, the feature extraction network provides power precision tenors(e.g., INT4, INT8) to the output block. The output block uses the lowerprecision output from the feature extraction network in combination withthe higher precision output from the input block to predict thepre-pixel kernels/blend weights used to filter the upscaled input andblend the filtered input with the previous output.

FIG. 45 illustrates exemplary rendering performance comparisons formultiple rendering techniques described herein. Rendering time for alow-quality rendering 4505, for example, at 1080p resolution, issignificantly lower than the rendering time for a high-quality rendering4501, for example, at 4K resolution. Traditional upscaling 4504 (TAAUpsampling, Temporal Super Resolution, FidelityFX Super Resolution)renders frames at low resolution and the low-resolution image isupsampled to the target display resolution to achieve performance boostand potentially an image quality improvement over low-quality rendering4505.

One implementation of temporally amortized supersampling using a mixedprecision convolutional neural network is X^(e) SS provided by Intel®Incorporated. X^(e) SS can be performed on hardware that includes amatrix accelerator (e.g., tensor accelerator 2723) via the use of IntelX^(e) Matrix Extensions (XMX). Rendering via X^(e) SS+XMX 4502 canproduce an image that is significantly higher quality that low qualityrendering 4505 or traditional upscaling 4504 and with significantlylower rendering times than high quality rendering 4501 at native 4Kresolutions. Rendering via X^(e) SS+DP4a 4503 replaces XMX with a dotproduct instruction (DP4a) that can be executed by a variety of graphicsprocessor architectures from a variety of vendors and results in ahigh-quality image and a rendering time that is still significantlylower than high quality rendering 4501 at native 4K resolutions. In oneembodiment, X^(e) SS+XMX 4502 is performed using direct reconstructionvia output block 4320A of FIG. 43A, while X^(e) SS+DP4a 4503 isperformed using kernel prediction and filtering via output block 4320Bof FIG. 43B.

Additional Exemplary Computing Device

FIG. 46 is a block diagram of a computing device 4600 including agraphics processor 4604, according to an embodiment. Versions of thecomputing device 4600 may be or be included within a communicationdevice such as a set-top box (e.g., Internet-based cable televisionset-top boxes, etc.), global positioning system (GPS)-based devices,etc. The computing device 4600 may also be or be included within mobilecomputing devices such as cellular phones, smartphones, personal digitalassistants (PDAs), tablet computers, laptop computers, e-readers, smarttelevisions, television platforms, wearable devices (e.g., glasses,watches, bracelets, smartcards, jewelry, clothing items, etc.), mediaplayers, etc. For example, in one embodiment, the computing device 4600includes a mobile computing device employing an integrated circuit(“IC”), such as system on a chip (“SoC” or “SOC”), integrating varioushardware and/or software components of computing device 4600 on a singlechip. The computing device 4600 can be a computing device includingcomponents illustrated in the data processing system 2700 as in of FIG.27 .

The computing device 4600 includes a graphics processor 4604. Thegraphics processor 4604 represents any graphics processor describedherein. In one embodiment, the graphics processor 4604 includes a cache4614, which can be a single cache or divided into multiple segments ofcache memory, including but not limited to any number of L1, L2, L3, orL4 caches, render caches, depth caches, sampler caches, and/or shaderunit caches. In one embodiment the cache 4614 may be a last level cachethat is shared with the application processor 4606.

In one embodiment the graphics processor 4604 includes a graphicsmicrocontroller that implements control and scheduling logic for thegraphics processor. The control and scheduling logic can be firmwareexecuted by the graphics microcontroller 4615. The firmware may beloaded at boot by the graphics driver logic 4622. The firmware may alsobe programmed to an electronically erasable programmable read onlymemory or loaded from a flash memory device within the graphicsmicrocontroller 4615. The firmware may enable a GPU OS 4616 thatincludes device management logic 4617 and driver logic 4618, and ascheduler 4619. The GPU OS 4616 may also include a graphics memorymanager 4620 that can supplement or replace the graphics memory manager4621 within the graphics driver logic 4622.

The graphics processor 4604 also includes a GPGPU engine 4644 thatincludes one or more graphics engine(s), graphics processor cores, andother graphics execution resources as described herein. Such graphicsexecution resources can be presented in the forms including but notlimited to execution units, shader engines, fragment processors, vertexprocessors, streaming multiprocessors, graphics processor clusters, orany collection of computing resources suitable for the processing ofgraphics resources or image resources or performing general purposecomputational operations in a heterogeneous processor. The processingresources of the GPGPU engine 4644 can be included within multiple tilesof hardware logic connected to a substrate, as illustrated in FIG.24B-24D. The GPGPU engine 4644 can include GPU tiles 4645 that includegraphics processing and execution resources, caches, samplers, etc. TheGPU tiles 4645 may also include local volatile memory or can be coupledwith one or more memory tiles, such as memory tiles 1626A-1626D as inFIG. 16B-16C.

The GPGPU engine 4644 can also include and one or more special tiles4646 that include, for example, a non-volatile memory tile 4656, anetwork processor tile 4657, and/or a general-purpose compute tile 4658.The GPGPU engine 4644 also includes a matrix multiply accelerator 4660.The general-purpose compute tile 4658 may also include logic toaccelerate matrix multiplication operations. The non-volatile memorytile 4656 can include non-volatile memory cells and controller logic.The controller logic of the non-volatile memory tile 4656 may be managedby one of device management logic 4617 or driver logic 4618. The networkprocessor tile 4657 can include network processing resources that arecoupled to a physical interface within the input/output (I/O) sources4610 of the computing device 4600. The network processor tile 4657 maybe managed by one or more of device management logic 4617 or driverlogic 4618.

In one embodiment, the matrix multiply accelerator 4660 is a modularscalable sparse matrix multiply accelerator. The matrix multiplyaccelerator 4660 can includes multiple processing paths, with eachprocessing path including multiple pipeline stages. Each processing pathcan execute a separate instruction. In various embodiments, the matrixmultiply accelerator 4660 can have architectural features of any one ofmore of the matrix multiply accelerators described herein. For example,in one embodiment, the matrix multiply accelerator 4660 is a systolicarray 3000 that is configurable to operate with a multiple of fournumber of logical stages (e.g., four, eight, twelve, sixteen, etc.). Inone embodiment the matrix multiply accelerator 4660 includes one or moreinstances of a two-path matrix multiply accelerator 3100 with afour-stage pipeline or a four-path matrix multiply accelerator 3200 witha two-stage pipeline. In one embodiment the matrix multiply accelerator4660 includes processing elements configured as a scalable sparse matrixmultiply accelerator. The matrix multiply accelerator 4660 can be usedto accelerate matrix operations performed via XMX extensions, or anothercompute library that facilitates the acceleration of matrix computeoperations. For example, the matrix multiply accelerator 4660 canperform tensor computations for training or inference of the neuralnetwork models 4050, 4100 described herein.

As illustrated, in one embodiment, and in addition to the graphicsprocessor 4604, the computing device 4600 may further include any numberand type of hardware components and/or software components, including,but not limited to an application processor 4606, memory 4608, andinput/output (I/O) sources 4610. The application processor 4606 caninteract with a hardware graphics pipeline to share graphics pipelinefunctionality. Processed data is stored in a buffer in the hardwaregraphics pipeline and state information is stored in memory 4608. Theresulting data can be transferred to a display controller for output viaa display device. The display device may be of various types, such asCathode Ray Tube (CRT), Thin Film Transistor (TFT), Liquid CrystalDisplay (LCD), Organic Light Emitting Diode (OLED) array, etc., and maybe configured to display information to a user via a graphical userinterface.

The application processor 4606 can include one or processors, such asprocessor(s) 102 of FIG. 1 and may be the central processing unit (CPU)that is used at least in part to execute an operating system (OS) 4602for the computing device 4600. The OS 4602 can serve as an interfacebetween hardware and/or physical resources of the computing device 4600and one or more users. The OS 4602 can include driver logic for varioushardware devices in the computing device 4600. The driver logic caninclude graphics driver logic 4622, which can include the user modegraphics driver 2326 and/or kernel mode graphics driver 2329 of FIG. 23. The graphics driver logic can include a graphics memory manager 4621to manage a virtual memory address space for the graphics processor4604. The graphics memory manager 4621 can facilitate a unified virtualaddress space that may be accessed by the application processor 4606 andthe graphics processor 4604.

It is contemplated that in some embodiments the graphics processor 4604may exist as part of the application processor 4606 (such as part of aphysical CPU package) in which case, at least a portion of the memory4608 may be shared by the application processor 4606 and graphicsprocessor 4604, although at least a portion of the memory 4608 may beexclusive to the graphics processor 4604, or the graphics processor 4604may have a separate store of memory. The memory 4608 may comprise apre-allocated region of a buffer (e.g., framebuffer); however, it shouldbe understood by one of ordinary skill in the art that the embodimentsare not so limited, and that any memory accessible to the lower graphicspipeline may be used. The memory 4608 may include various forms ofrandom-access memory (RAM) (e.g., SDRAM, SRAM, etc.) comprising anapplication that makes use of the graphics processor 4604 to render adesktop or 3D graphics scene. A memory controller hub, such as memorycontroller 1416 of FIG. 14 , may access data in the memory 4608 andforward it to graphics processor 4604 for graphics pipeline processing.The memory 4608 may be made available to other components within thecomputing device 4600. For example, any data (e.g., input graphics data)received from various I/O sources 4610 of the computing device 4600 canbe temporarily queued into memory 4608 prior to their being operatedupon by one or more processor(s) (e.g., application processor 4606) inthe implementation of a software program or application. Similarly, datathat a software program determines should be sent from the computingdevice 4600 to an outside entity through one of the computing systeminterfaces, or stored into an internal storage element, is oftentemporarily queued in memory 4608 prior to its being transmitted orstored.

The I/O sources can include devices such as touchscreens, touch panels,touch pads, virtual or regular keyboards, virtual or regular mice,ports, connectors, network devices, or the like, and can attach via aplatform controller hub 1430 as referenced in FIG. 14 . Additionally,the I/O sources 4610 may include one or more I/O devices that areimplemented for transferring data to and/or from the computing device4600 (e.g., a networking adapter); or, for a large-scale non-volatilestorage within the computing device 4600 (e.g., SSD/HDD). User inputdevices, including alphanumeric and other keys, may be used tocommunicate information and command selections to graphics processor4604. Another type of user input device is cursor control, such as amouse, a trackball, a touchscreen, a touchpad, or cursor direction keysto communicate direction information and command selections to GPU andto control cursor movement on the display device. Camera and microphonearrays of the computing device 4600 may be employed to observe gestures,record audio and video and to receive and transmit visual and audiocommands.

The I/O sources 4610 can include one or more network interfaces. Thenetwork interfaces may include associated network processing logicand/or be coupled with the network processor tile 4657. The one or morenetwork interface can provide access to a LAN, a wide area network(WAN), a metropolitan area network (MAN), a personal area network (PAN),Bluetooth, a cloud network, a cellular or mobile network (e.g., 3^(rd)Generation (3G), 4^(th) Generation (4G), 5^(th) Generation (5G), etc.),an intranet, the Internet, etc. Network interface(s) may include, forexample, a wireless network interface having one or more antenna(e).Network interface(s) may also include, for example, a wired networkinterface to communicate with remote devices via network cable, whichmay be, for example, an Ethernet cable, a coaxial cable, a fiber opticcable, a serial cable, or a parallel cable.

Network interface(s) may provide access to a LAN, for example, byconforming to IEEE 802.11 standards, and/or the wireless networkinterface may provide access to a personal area network, for example, byconforming to Bluetooth standards. Other wireless network interfacesand/or protocols, including previous and subsequent versions of thestandards, may also be supported. In addition to, or instead of,communication via the wireless LAN standards, network interface(s) mayprovide wireless communication using, for example, Time Division,Multiple Access (TDMA) protocols, Global Systems for MobileCommunications (GSM) protocols, Code Division, Multiple Access (CDMA)protocols, and/or any other type of wireless communications protocols.

Temporally Stable Joint Denoising And Supersampling Using Single MixedPrecision CNN

Temporally amortized supersampling is performed by combining a currentframe and a previous output frame warped with the current motionvectors. Temporal Anti-aliasing (TAA) is an anti-aliasing technique inwhich the renderer jitters the camera every frame to sample differentcoordinates in screen space. The TAA stage accumulates these samplestemporally to produce a supersampled image.

Ray tracing enables realistic light transport simulation and, because ofavailable hardware support, ray tracing has become viable in games.However, the computational cost of ray tracing remains high and it ischallenging to render high-quality ray-traced images in real time with ahigh spatial and temporal resolution. Low ray tracing budgets lead tohigher variance, which manifests as noise in the final image.Furthermore, an image also exhibits aliasing due to undersampling ofprimary rays, which results in spatial and temporal artifacts, such asjagged edges and flickering.

There are denoising and supersampling techniques that reuse samplesacross space and time to reconstruct high-quality final images. TAAreprojects samples from a previous frame using motion vectors from therenderer and applies heuristics to accumulate with the current framesamples. However, when the heuristics fail, TAA suffers from visualartifacts in the form of ghosting, over-blurring, and flickering. Toreduce noise, spatiotemporal filters may be designed based on frequencyanalysis of light transport or variance estimation over time. Thesehandcrafted filtering techniques can introduce various artifacts,including loss of details, temporal lag, and residual noise.

Neural reconstruction techniques are becoming more common in real-timerendering due to their ability to produce high-quality images fromundersampled inputs through an end-to-end learning process. While neuralnetwork denoisers have become a standard reconstruction technique foroffline and interactive rendering, these still pose challenges in gamesdue to the cost associated with the network. Moreover, chaining a neuralnetwork denoiser with a neural network supersampling technique may beimpractical in most scenarios as it would exceed the rendering budget ofa single frame.

In some embodiments, a novel real-time neural reconstruction techniqueperforms denoising and supersampling jointly using a single neuralnetwork. The technique may be applied to achieve significantly betterimage quality than existing analytical or statistical denoisers. Anembodiment of a frame-recurrent network takes a noisy and aliasedlow-resolution input, and reconstructs a high-resolution, denoised, andsupersampled output.

In some embodiments, a graphics processor includes a set of processingresources configured to perform a supersampling operation; and a singleneural network (such as a mixed-precision convolutional neural network(CNN)) to jointly perform denoising and supersampling, wherein theneural network includes an input block, a feature extraction and kernelprediction network, and a filtering block.

In some embodiments, features are shared among multiple filtering stagesthat attend to different components of the input signal. The inputsignal may be decomposed into albedo demodulated diffuse (diffusereflection referring to the reflection of light in many directions),specular (specular reflection referring to light reflected from asurface at a definite angle), and albedo (albedo referring to aproportion of incident light that is reflected away from a surface)elements, with each filter stage being responsible for one of thecomponents. At each filter stage, a set of kernel weights is generatedthat are hierarchically applied to obtain large spatial footprints.Further, samples are accumulated from a reprojected previous frame usingmotion vectors to produce temporally stable results.

In some embodiments, to further enhance the quality of the output, a newnetwork-based perceptual loss function is trained, the loss functionbeing designed for extracting features from a rendered image. This lossfunction reduces the structural artifacts (neural hallucinations)usually seen with VGG-based loss functions (VGG referring to VisualGeometry Group), which are trained using natural images. The lossnetwork is trained to solve a segmentation task on photorealisticsynthetic data rendered for indoor scene understanding.

In some embodiments, an apparatus or system may utilize reducedprecision input that is upsampled to a higher, target resolution withoutsignificant loss in performance. In a particular implementation,supersampled results from a 1280×720 input can produce competitivequality in comparison with existing denoisers that are fed with an inputat 2560×1440 (i.e. four times more samples).

Currently in rendering engines, it is possible to render a frame in acertain target resolution. Because this is real-time, the frame cannotbe rendered completely, and as result artifacts will appear as noise inthe image. For this reason, a denoise process is included. Followingthis, to fix the aliasing issues generated with pixel sampling, a TAAstage provides supersampling processing.

In newer technologies, a system can render in a lower resolution thanthe resolution supported by the display, and then can denoise in thelower resolution. This may be followed by an upsampler. In someembodiments, the upsampler is a neural network based upsampler, whichprovides good results. However, the denoiser is not neural network basedbecause it is very costly to implement a neural network based denoiser,although such aa denoiser generally provides much better performancethan other technologies.

Further, in comparison with a system that utilizes a same inputresolution as the target resolution, an embodiment may receive a reducedinput resolution for accelerated processing, with a higher resolutionoutput. In this manner, the processing speed may be greatly increased incomparison with existing technologies. For example, the input and outputresolutions for a for an existing denoising technology operation, suchas SVGF (Spatiotemporal Variance-Guided Filtering) or a UE4 denoiser,and an embodiment providing joint denoising and supersampling may be asprovided in Table 5.

TABLE 5 Input Resolution Output Resolution Existing Technology 2560 ×1440 2560 × 1440 Joint Denoising and 1280 × 720  2560 × 1440Supersampling

FIGS. 47A, 47B, and 47C are illustrations of a reconstruction pipeline,according to some embodiments. FIG. 47A illustrates a native resolutionpipeline 4710, FIG. 47B illustrates an upscaled pipeline 4720, and FIG.47C illustrates an embodiment of a joint denoising and supersamplingpipeline. In particular, a reconstruction pipeline may be directedtoward a hybrid rendering system combining rasterization techniques withray traced effects for soft shadows, glossy reflections, and diffuseglobal illumination.

As shown in FIG. 47A, the native resolution pipeline 4710 receives aninput at a native resolution (such as 2560×1440) and generates an outputat the same native resolution. The pipeline 4710 includes G-buffer(Graphics Buffer) 4712, ray trace 4714, denoise 4716, and TAA 4718. Thenative resolution pipeline 4710 thus requires processing at the nativeresolution, and provides for separate denoising by the denoiser 4716 andsupersampling by TAA 4718. Even with ray tracing use cases, rendering atdisplay resolution is expensive, and thus the native resolution pipeline4710 may be impractical for many use cases, including gaming operations.

In FIG. 47B, the upscaled pipeline 4720 receives an input at a reducedresolution (such as 1280×720) and generates an output at a higher targetresolution (such as 2560×1440). The pipeline 4720 includes G-buffer4722, ray trace 4724, denoise 4726, and upscaler 4728. Modern graphicshardware and game engines generally support rendering at a lowerresolution followed by upscaling to a higher target resolution, asprovided by the pipeline 4720. In this manner, the upscaled pipeline4720 allows for processing at a lower resolution, thus assisting withprocessing costs. Upscaling can be done spatially or temporally withsupersampling. However, the pipeline still requires separate denoisingby the denoiser 4726 and supersampling by the upscaler 4728, with theresulting high processing costs.

In some embodiments, an apparatus, system, or process is to performdenoising and supersampling jointly using a single mixed-precisionneural network, such as a convolutional neural network. An embodimentwill perform super-resolution, super-sampling denoising in a singlenetwork. As shown in FIG. 47C, a joint denoising and supersamplingpipeline 4730 receives an input at a reduced resolution (such as1280×720) and generates an output at a higher target resolution (such as2560×1440). The pipeline 4730 includes G-buffer 4732, ray trace 4734,and, in contrast with separate denoising and supersampling utilized inexisting technologies, provides joint neural denoise and supersampling4740. Thus, the pipeline 4730 allows for both processing at a lowerresolution, and combined denoising and supersampling utilizing a singleneural network.

FIG. 48 illustrates a joint neural denoiser and supersampler for agraphics reconstruction pipeline, according to some embodiments. In someembodiments, an apparatus, system, or process includes a single featureextraction network and several filtering stages, wherein the networkimplements the single neural network to provide both denoising andsupersampling operation, thus significantly reducing the computationalcosts of such operations. In one implementation, a U-Net-based featureextractor (U-Net referring to a specific CNN architecture) is set toapply a limited precision (for example, 8-bit integer precision) and runat a lower resolution, aiding in faster execution. The resulting outputserves to provide denoising as well as supersampling.

FIG. 48 illustrates details of a joint neural denoising andsupersampling architecture 4800, comprising of an input block, a featureextractor, filter paths, an output block, and an upsample block, asfurther described below. The input to the network comprises a set ofuntextured illumination components and auxiliary features together withper-pixel motion vectors from the renderer. The noisy illuminationcomponents are combined into a low-frequency diffuse signal and ahigh-frequency specular signal. The auxiliary features include albedo,normal, and roughness that guide the network to distinguish betweenscene details and noise, and avoiding overblurring. The input block,output block and the filtering stages operate in the native resolution,while the feature extraction runs in a sub-native (reduced) resolution.The upsample block filters the composited result from the filteringstage at the target resolution. In a particular implementation, theweights and activations of all non-filter blocks use 8-bit integers,leveraging quantization-aware training to support fast inferenceperformance, and the filter blocks use 16-bit floats.

As illustrated, a joint neural denoiser and supersampler 4800 (alsoreferred to herein as a joint denoiser/supersampler) includes a network4820 including a single shared feature extractor 4822, multiple filterpaths 4824, and an upsample block 4826 to provide an image output 4850.In some embodiments, an apparatus, system, or process applying the jointneural denoiser and supersampler 4800 to combine multiple reconstructiontasks into a single pass in a rendering pipeline, such as pipeline 4730illustrated in FIG. 47C. The pipeline may be applied to work with lowsample counts while producing temporally stable high-quality results.

In some embodiments, the feature extractor is to consume albedo 4802,diffuse 4804 (diffuse and diffuse GI), specular 4806 (direct specularand reflections), and normal 4808 buffers from the current and previousframe. Results from the previous frame are already filtered and warpedusing motion vectors, as illustrated by the warp 4816. Throughapplication of albedo demodulation 4812, diffuse filtering 4804 does notblur albedo textures. The supersampled normal 4808 acts as a guidingfeature to avoid extreme cases of ghosting. In addition, the currentroughness 4810 is provided to prevent overblurring in the specularfiltering. As further illustrated, the diffuse 4804 (following albedodemodulation 4812) and specular 4806 data are processed by a tonemapper4814 prior to processing by the network.

In an operation, ray tracing passes generate noisy signals for diffuseand specular. An embodiment uses two separate multi-scale filter pathsfor these signals, denoised diffuse 4832 and denoised specular 4834.These filter paths derive their filter weights from output of the sharedfeature extractor 4822. Further, the aliased albedo and normal from theg-buffer get supersampled using the same output, illustrated assupersampled albedo 4830. The signals are composited together, composite4836, before these enter upsampling (upsample block 4826) withsuper-resolution, referring to techniques to enhance the resolution ofan imaging system. This operation further utilizes the output of theshared feature extractor 4822.

In some embodiments, a graphics processor includes multiple processingresources, including a least a first processing resource including apipeline to perform a supersampling operation; and the pipelineincluding circuitry to jointly perform denoising and supersampling ofreceived ray tracing input data, the circuitry including first circuitryto receive input data associated with an input block for a neuralnetwork, second circuitry to perform operations associated with afeature extraction and kernel prediction network of the neural network,and third circuitry to perform operations associated with a filteringblock of the neural network.

FIG. 49A is an illustration of joint denoising and supersampling in agraphics architecture, according to some embodiments. In an apparatus4900, input signals 4930 are received at a low resolution, illustratedas the albedo 4932, diffuse 4934, specular 4936, normal 4938, androughness 4939, received for upsampling of signals 4940. Further, motionvectors 4910 (velocity 4912, jitter 4914, and depth 4916) are utilizedin upsampling of signals 4940 from the input signals and in upsamplingvelocity 4920 of the image data. The upsampling of signals 4940generates upsampled signals for processing by a neural network model4942 that includes a single shared feature extractor 4944.

The neural network model 4942 generates output signals 4950 at a higher(target) resolution, the output signals including albedo 4952, diffuse4954, specular 4956, and normal 4958 components. The neural networkmodel 4942 further receives warping data (warp 4920) based on theprevious frame from the output signals 4950 and the upsampled velocity4920 of the motion vectors 4910.

In some embodiments, the neural network model 4942 includes a featureextractor 4944 made of multiple convolution layers that operate on lowprecisions such as INT4 or INT8 to achieve fast computational speed. Thefeature extractor 4944 outputs features from noisy light signals (e.g.,1 sample per pixel) and G-buffers data. The features are to be sharedbetween multiple filtering stages that generate a set of filters thatare then hierarchically applied to the signal that each stage isprocessing (as further illustrated in FIG. 50 ), where diffuse andspecular filtering stages apply spatial and temporal kernels fordenoising while the G-buffer filtering stages apply spatial and temporalkernels for supersampling.

In some embodiments, a system provides the following:

(1) The task of denoising and supersampling is performed jointly using areduced precision single neural network achieving faster inferenceperformance without any loss in image quality.

(2) The light and texture components are filtered separately beforecompositing using predicted spatial and temporal kernels.

(3) The feature extractor 4944 is shared between multiple filter stages,where these predict a set of filters specific for the input signal.

FIG. 49B is an illustration of joint denoising and supersampling in analternative graphics architecture, according to some embodiments. Insome embodiments, upsampling may also follow neural network processing,rather than preceding it as shown in FIG. 49A. In an apparatus 4960 aspresented in FIG. 49B, input signals 4930 are received at a lowresolution, again illustrated as the albedo 4932, diffuse 4934, specular4936, normal 4938, and roughness 4939, for processing by neural networkmodel 4962 that includes a single shared feature extractor 4964.Following the neural network processing, the processed data is receivedfor upsampling of signals 4966. Motion vectors 4910 (velocity 4912,jitter 4914, and depth 4916) are utilized in the upsampling of signals4966 from the processed signals and in upsampling velocity 4920 of theimage data.

The neural network model 4962 generates signals that are upsampled 4966to generate output signals 4950 at a higher (target) resolution, theoutput signals including albedo 4952, diffuse 4954, specular 4956, andnormal 4958 components. The neural network model 4962 further receiveswarping data (warp 4920) based on the previous frame from the outputsignals 4950 and the upsampled velocity 4920 of the motion vectors 4910.

FIG. 50 is an illustration of a joint denoising and supersampling neuralnetwork, according to an embodiment. As illustrated in FIG. 50 , aneural network model 5000 includes three components: an input block5020, a feature extraction and kernel prediction network 5040 (alsoreferred to herein as a feature extraction network), and a filteringblock 5050. The neural network model 5000 receives at the input block5020 the current input signals 5030, comprising the albedo 5032, diffuse5034, specular 5034, and normal 5038 components, and the roughness data5039, and the motion vectors (velocity 5012, jitter 5014, and depth 5016information).

In some embodiments, the feature extraction network includes a series ofencoder-decoder blocks with skip connections between them. Each encoderblock can have multiple convolution, activation, and downsampleoperations. Each decoder block includes upsample, convolution, andactivation operations. The output of each decoder block and a bottleneckblock is sent to a 1×1 convolution layer per filter block to predict aper-pixel kernel and a weight value for each spatial resolution. This isillustrated as Encoder Block 1, Encoder Block 2, and continuing throughEncoder Block n, a bottleneck block, and Decoder Block n continuingthrough Decoder Block 2, and Decoder Block 1.

In some embodiments, the neural network 5000 includes a filtering block5050 providing multiple filtering paths, wherein the filter paths mayinclude an albedo filtering path 5052 (which may include albedo andnormal filtering), a specular filtering path 5054, and a diffusefiltering path 5056. Also illustrated are the previous output signals5060 as fed back from the filtering block 5050 to the input block 5020,and the current input and previous output signals 5062 provided to thefiltering block 5050.

In some embodiments, within the filtering block 505 there is onefiltering path per input signal processed that receives a unique set ofkernels, which is then applied hierarchically to filter the inputsignal. The weight values are used to blend between the signals invarious filtering steps. The output signals from the filtering block aresent to the input block 5020 for warping for a next frame.

In a particular implementation, each encoder block consists of two 3×3convolution layers followed by a ReLU activation and a max-poolingoperation before proceeding to the next block. In the decoder blocks,the first process is bilinear upsampling of the feature map from theprevious block, followed by two 3×3 convolution layers and a ReLUactivation. Prior to applying convolution kernels in the decoder block,skip connections from encoders are concatenated with the upsampledactivation to recover high-frequency details. Two 1×1 convolution layersper block share the activations from the decoder and bottleneck block toderive hierarchical filter weights for the filtering stages. The filterkernel weights are applied to the linear diffuse and specular signals intheir corresponding filter path.

By using a multi-scale filtering layout resembling the U-Netarchitecture instead of predicting and applying a single large filter,the computational cost may be reduced. In contrast with a U-Net,however, there are no learnable parameters in the filter paths becauseall filter and blend weights are predicted by the decoder of the featureextraction network 5040 and the output block of the neural network. Thefilter layout comprises of a spatiotemporal filter and a series ofdownsampling filters followed by upsampling filters with skipconnections. The spatiotemporal filter applies different 3×3 kernels tothe current frame and the filtered and warped output of the previousframe. The results are blended linearly. The downsampling filters apply2×2 average pooling, followed by filtering with a 3×3 kernel. Upsamplingfilters employ bilinear upsampling and 3×3 kernels and then combine theresult linearly with a skip image of the same resolution. While thediffuse and specular filter paths use a hierarchical filtering schemewith unique kernel weights, the albedo and normal filter paths only usea spatiotemporal filter at the native resolution and weights are sharedbetween albedos and normals. The output of each filter uses a ReLUactivation function.

By upsampling a composite image rather than individual signals, fewerfiltering operations are needed at the target resolution. In someembodiments, the fixed compositing function provided in equation (3) isapplied during training. However, embodiments are not limited to thiscompositing function, and another compositor may also be implemented.

Composite:=Albedo·Diffuse+Specular  (3)

In some embodiments, a two-step bilinear upsampling process is appliedto produce a tonemapped and a linear version of the composite. Thetonemapped composite is concatenated with the features from the outputblock and is passed to a kernel prediction stage. Similar to otherkernel prediction blocks, a 3×3 per pixel kernel is predicted in thetarget resolution. The predicted weights and the upsampled composite(without tonemapping) is sent to the final filter block, where thekernel weights are applied to get the final output image.

In some embodiments, the quantized layers are set to use 8-bit integerweights and activations, where the weights follow a per-channelsymmetric quantization, while the activations use an affine per-layerquantization. When the skip layers are combined, the same quantizationrange is used. The quantization threshold for the weights is set totheir maximum absolute value per channel with symmetric range. Foractivations, the threshold is trained by setting a straight throughestimator for the gradient of non-differentiable functions. Becausebatch normalization is not used in the network, folding of weights isnot required.

Neural denoising has proven itself to be a valuable tool for offlinerendering but used to be too costly for real-time applications. Neuralsupersampling on the other hand has seen quick adoption. By performingthese two tasks jointly, we reduce their combined cost such that neuralreal-time denoising in games becomes viable. Our technique produceshigh-quality and high-resolution output from low-resolution input. Thishigh quality is partly due to our specially designed loss functions. Thecost per frame is still significant, but the reduction of the shadingrate easily makes up for that. Low-precision arithmetic helps to lowercompute and bandwidth requirements.

FIG. 51 is an illustration of an input block for a neural networkutilized in joint denoising and supersampling, according to someembodiments. In some embodiments, an input block 5120 (such as the inputblock 5020 of a neural network model 5000 in FIG. 50 ) receives thecurrent input signals 5130, comprising the albedo 5132, diffuse 5134,specular 5136, and normal 5138 components, and the roughness data 5139,and the velocity 5112, jitter 5114, and depth 5116 information. In someembodiments, the input block 5120 includes an upsample layer 5122,warping 5124, shuffling from space to depth 5126, and convolution andactivation 5128. The input block further processed for providing currentinput and previous warped signals to filtering blocks 5152 (such as tofiltering blocks 5050 of a neural network model 5000 illustrated in FIG.50 ), and sending a processed signal to the feature extractor (such asfeature extraction and kernel prediction network 5040 of a neuralnetwork model 5000 as illustrated in FIG. 50 ). In an alternativeembodiment, the upsample layer 5122 is not contained within the inputblock 5120 as upsampling is instead provided following neural networkprocessing, such as illustrated in FIG. 49B.

In some embodiments, the upsample layer 5122 the input block is toupsample the input signals that are sent to the feature extractor and tothe filtering blocks. The previous output signals are subjected towarping 5124 to aid in temporal accumulation. For faster inferenceperformance, pixels in the spatial dimensions are shuffled to channeldimension (shuffle from space to depth 5126). In convolution andactivation 5128, a 1×1 convolution and ReLU activation is applied in adimension reduction process.

FIG. 52 is an illustration of a process for joint denoising andsupersampling utilizing a shared neural network, according to someembodiments. As illustrated in FIG. 52 , a process 5200 includesperforming ray tracing for a graphics application 5205. The graphicsapplication may include a video game application, where the ray racingdata may suffer from noise and aliasing, resulting in jagged images. Theray tracing data may be received for supersampling processing 5210 toimprove the image quality. The received data may be data at a inputresolution (a first resolution) that is lower than a target resolution(second resolution) for the data. The received data may include albedo,diffuse, specular, and normal components, and may further includeroughness information for the input data.

As further provided in process 5200, the received data may be upsampledfrom the input resolution to target resolution 5215, and previous outputdata is warped with motion vector data (velocity, jitter, and depthinformation) 5220. In some embodiments, the upsampled data and thewarped data are received at a neural network including a featureextractor 5225. The neural network may include a mixed-precisionconvolutional neural network (CNN). In some embodiments, the receiveddata is processed by the neural network 5230, wherein the processingincludes both denoising and supersampling providing anti-aliasing of thedata through a single neural network process. In an alternativeembodiment, the received data is not upsampled 5215, with the upsamplinginstead being performed following neural network processing.

In some embodiments, the processed data may be filtered using multiplefiltering paths 5235. For example, the multiple filtering paths mayinclude an albedo/normal filtering path, a specular filtering path, anda diffuse filtering path for filtering of the components of the imagedata.

In some embodiments, the filtered data may be outputted for imaging inthe graphics application 5240. The process 5200 thus enablessupersampling processing of ray trace image to produce improved imagequality, while only requiring a single neural network process fordenoising and anti-aliasing of the image data.

The following Examples pertain to certain embodiments:

In Example 1, a graphics processor comprises a plurality of processingresources, including a least a first processing resource including apipeline to perform a supersampling operation; and the pipelineincluding circuitry to jointly perform denoising and supersampling ofreceived ray tracing input data, the circuitry including first circuitryto receive input data associated with an input block for a neuralnetwork, second circuitry to perform operations associated with afeature extraction and kernel prediction network of the neural network,and third circuitry to perform operations associated with a filteringblock of the neural network.

In Example 2, the feature extraction and kernel prediction networkincludes a plurality of convolution layers, the second circuitryconfigured to perform operations associated with the plurality ofconvolution layers; and the plurality of convolution layers operate at afirst precision and the filtering block operates at a second precision,the first precision being lower than the second precision.

In Example 3, the first precision includes either INT4 or INT8.

In Example 4, the first circuitry is to upsample the received input datafrom a first resolution to a second resolution.

In Example 5, the first circuitry is further to warp a previous outputfrom the third circuitry using motion data to generate warped data; andprovide the warped data to the second circuitry for processing.

In Example 6, the filtering block includes a plurality of differentfiltering paths for different components of graphics data.

In Example 7, the plurality of different filtering paths includes analbedo filtering path; a specular filtering path; and a diffusefiltering path.

In Example 8, the neural network is a mixed-precision convolutionalneural network (CNN).

In Example 9, a method comprises receiving ray tracing input data at aprocessing resource including a pipeline to perform a supersamplingoperation, the pipeline including circuitry associated with operationsof a neural network; processing the received input data at the neuralnetwork to perform both denoising and supersampling of the input data;and filtering the processed data at a filtering block.

In Example 10, processing the received input data at the neural networkincludes processing utilizing a plurality of convolution layers; and theplurality of convolution layers operate on a first precision and thefiltering block operates on a second precision, the first precisionbeing lower than the second precision.

In Example 11, the method further comprises upsampling the receivedinput data from a first resolution to a second resolution.

In Example 12, the method further comprises warping a previous outputfrom the pipeline using motion data to generate warped data; andproviding the warped data to the neural network for processing.

In Example 13, filtering the processed data at a filtering blockincludes filtering with a plurality of different filtering paths fordifferent components of graphics data.

In Example 14, filtering the processed data includes filtering with analbedo filtering path; filtering with a specular filtering path; andfiltering with a diffuse filtering path.

In Example 15, or more non-transitory computer-readable storage mediumshaving stored thereon executable computer program instructions that,when executed by one or more processors, cause the one or moreprocessors to perform operations comprising receiving ray tracing inputdata at a processing resource including a pipeline to perform asupersampling operation, the pipeline including circuitry associatedwith operations of a neural network; processing the received input dataat the neural network to perform both denoising and supersampling of theinput data; and filtering the processed data at a filtering block.

In Example 16, processing the received input data at the neural networkincludes processing utilizing a plurality of convolution layers; and theplurality of convolution layers operate on a first precision and thefiltering block operates on a second precision, the first precisionbeing lower than the second precision.

In Example 17, the instructions further comprise instructions that, whenexecuted by the one or more processors, cause the one or more processorsto perform operations comprising upsampling the received input data froma first resolution to a second resolution.

In Example 18, the instructions further comprise instructions that, whenexecuted by the one or more processors, cause the one or more processorsto perform operations comprising warping a previous output from thepipeline using motion data to generate warped data; and providing thewarped data to the neural network for processing.

In Example 19, filtering the processed data at a filtering blockincludes filtering with a plurality of different filtering paths fordifferent components of graphics data.

In Example 20, filtering the processed data includes filtering with analbedo filtering path; filtering with a specular filtering path; andfiltering with a diffuse filtering path.

In Example 21, an apparatus comprising means for receiving ray tracinginput data at a processing resource including a pipeline to perform asupersampling operation, the pipeline including a neural network; meansfor processing the received input data at the neural network to performboth denoising and supersampling of the input data; and means forfiltering the processed data at a filtering block.

In Example 22, the means for processing the received input data at theneural network includes means for processing utilizing a plurality ofconvolution layers; and the plurality of convolution layers operate on afirst precision and the filtering block operates on a second precision,the first precision being lower than the second precision.

In Example 23, the apparatus further comprises means for upsampling thereceived input data from a first resolution to a second resolution.

In Example 24, the apparatus further comprises means for warping aprevious output from the pipeline using motion data to generate warpeddata; and means for providing the warped data to the neural network forprocessing.

In Example 25, the means for filtering the processed data at a filteringblock includes means for filtering with a plurality of differentfiltering paths for different components of graphics data.

In Example 26, the means for filtering the processed data includes meansfor filtering with an albedo filtering path; filtering with a specularfiltering path; and filtering with a diffuse filtering path.

In Example 27, a graphics processor comprises a plurality of processingresources, including a least a first processing resource including apipeline to perform a supersampling operation; and the pipelineincluding circuitry associated with operations of a neural network tojointly perform denoising and supersampling of received ray tracinginput data, the neural network including an input block, a featureextraction and kernel prediction network, and a filtering block.

It is to be appreciated that a lesser or more equipped system than theexample described above may be preferred for certain implementations.Therefore, the configuration of the computing devices described hereinmay vary from implementation to implementation depending upon numerousfactors, such as price constraints, performance requirements,technological improvements, or other circumstances. Examples include(without limitation) a mobile device, a personal digital assistant, amobile computing device, a smartphone, a cellular telephone, a handset,a one-way pager, a two-way pager, a messaging device, a computer, apersonal computer (PC), a desktop computer, a laptop computer, anotebook computer, a handheld computer, a tablet computer, a server, aserver array or server farm, a web server, a network server, an Internetserver, a work station, a mini-computer, a main frame computer, asupercomputer, a network appliance, a web appliance, a distributedcomputing system, multiprocessor systems, processor-based systems,consumer electronics, programmable consumer electronics, television,digital television, set top box, wireless access point, base station,subscriber station, mobile subscriber center, radio network controller,router, hub, gateway, bridge, switch, machine, or combinations thereof.

One embodiment provides a graphics processor comprising a set ofprocessing resources configured to perform a supersampling anti-aliasingoperation via a mixed precision convolutional neural network. The set ofprocessing resources includes circuitry configured to receive, at aninput block of a neural network model, a set of data including previousframe data, current frame data, and velocity data. The previous framedata includes one or more previously generated output frames. Thecurrent frame data includes output of a raster and lighting stage of arender pipeline. The velocity data includes motion vectors generated bythe render pipeline. The circuitry can pre-process the set of data togenerate pre-processed data, provide first pre-processed data to afeature extraction network of the neural network model and providesecond-processed data to an output block of the neural network model.The first pre-processed data is provided at a first precision, such as atwo-bit, four-bit, or eight-bit integer precision. The secondpre-processed data is provided at a second precision that is higher thanthe first precision, such as a 16-bit floating point precision.

The circuitry can process the first pre-processed data at the featureextraction network via one or more encoder stages and one or moredecoder stages, output tensor data from the feature extraction networkto the output block, and generate an output frame via the output blockbased on the second pre-processed data from the input block and thetensor data output from the feature extraction network. The generatedoutput frame is an anti-aliased frame. To generate the pre-processeddata includes to warp the previous frame data based on the velocity datato generate warped history data, align the warped history data with thecurrent frame data to generate aligned history data, and shuffle thealigned history data and current frame data from a spatial dimension toa channel dimension. The channel dimension includes a depth channel ormultiple feature map channels.

In one embodiment, to generate an output frame via the output blockincludes to generate the output frame via one or more convolution layersof the output block. In one embodiment, to generate an output frame viathe output block includes to predict a set of per-pixel kernel valuesand blend weights, filter the current frame data via the per-pixelkernel values, and blend the aligned history data with filtered currentframe data. In one embodiment, the circuitry is configured to upscalethe output of the raster and lighting stage from a first resolution to asecond resolution that is higher than the first resolution before thecurrent frame data is provided to the input block of the neural networkmodel. In one embodiment, the output of the raster and lighting stage isupscaled during pre-processing.

An additional embodiment provides a method to perform the operations ofthe graphics processor described above. A further embodiment provides adata processing system including the graphics processor described above.

The foregoing description and drawings are to be regarded in anillustrative rather than a restrictive sense. Persons skilled in the artwill understand that various modifications and changes may be made tothe embodiments described herein without departing from the broaderspirit and scope of the features set forth in the appended claims.

What is claimed is:
 1. A graphics processor comprising: a plurality ofprocessing resources, including a least a first processing resourceincluding a pipeline to perform a supersampling operation; and thepipeline including circuitry to jointly perform denoising andsupersampling of received ray tracing input data, the circuitryincluding: first circuitry to receive input data associated with aninput block for a neural network, second circuitry to perform operationsassociated with a feature extraction and kernel prediction network ofthe neural network, and third circuitry to perform operations associatedwith a filtering block of the neural network.
 2. The graphics processorof claim 1, wherein: the feature extraction and kernel predictionnetwork includes a plurality of convolution layers, the second circuitryconfigured to perform operations associated with the plurality ofconvolution layers; and the plurality of convolution layers operate at afirst precision and the filtering block operates at a second precision,the first precision being lower than the second precision.
 3. Thegraphics processor of claim 2, wherein the first precision includeseither INT4 or INT8.
 4. The graphics processor of claim 1, wherein thefirst circuitry is to: upsample the received input data from a firstresolution to a second resolution.
 5. The graphics processor of claim 4,wherein the first circuitry is further to: warp a previous output fromthe third circuitry using motion data to generate warped data; andprovide the warped data to the second circuitry for processing.
 6. Thegraphics processor of claim 1, wherein the filtering block includes aplurality of different filtering paths for different components ofgraphics data.
 7. The graphics processor of claim 6, wherein theplurality of different filtering paths includes: an albedo filteringpath; a specular filtering path; and a diffuse filtering path.
 8. Thegraphics processor of claim 1, wherein the neural network is amixed-precision convolutional neural network (CNN).
 9. A methodcomprising: receiving ray tracing input data at a processing resourceincluding a pipeline to perform a supersampling operation, the pipelineincluding circuitry associated with operations of a neural network;processing the received input data at the neural network to perform bothdenoising and supersampling of the input data; and filtering theprocessed data at a filtering block.
 10. The method of claim 9, wherein:processing the received input data at the neural network includesprocessing utilizing a plurality of convolution layers; and theplurality of convolution layers operate on a first precision and thefiltering block operates on a second precision, the first precisionbeing lower than the second precision.
 11. The method of claim 9,further comprising: upsampling the received input data from a firstresolution to a second resolution.
 12. The method of claim 9, furthercomprising: warping a previous output from the pipeline using motiondata to generate warped data; and providing the warped data to theneural network for processing.
 13. The method of claim 9, whereinfiltering the processed data at a filtering block includes filteringwith a plurality of different filtering paths for different componentsof graphics data.
 14. The method of claim 13, wherein filtering theprocessed data includes: filtering with an albedo filtering path;filtering with a specular filtering path; and filtering with a diffusefiltering path.
 15. One or more non-transitory computer-readable storagemediums having stored thereon executable computer program instructionsthat, when executed by one or more processors, cause the one or moreprocessors to perform operations comprising: receiving ray tracing inputdata at a processing resource including a pipeline to perform asupersampling operation, the pipeline including circuitry associatedwith operations of a neural network; processing the received input dataat the neural network to perform both denoising and supersampling of theinput data; and filtering the processed data at a filtering block. 16.The one or more non-transitory computer-readable storage mediums ofclaim 15, wherein: processing the received input data at the neuralnetwork includes processing utilizing a plurality of convolution layers;and the plurality of convolution layers operate on a first precision andthe filtering block operates on a second precision, the first precisionbeing lower than the second precision.
 17. The one or morenon-transitory computer-readable storage mediums of claim 15, furthercomprising instructions that, when executed by the one or moreprocessors, cause the one or more processors to perform operationscomprising: upsampling the received input data from a first resolutionto a second resolution.
 18. The one or more non-transitorycomputer-readable storage mediums of claim 15, further comprisinginstructions that, when executed by the one or more processors, causethe one or more processors to perform operations comprising: warping aprevious output from the pipeline using motion data to generate warpeddata; and providing the warped data to the neural network forprocessing.
 19. The one or more non-transitory computer-readable storagemediums of claim 15, wherein filtering the processed data at a filteringblock includes filtering with a plurality of different filtering pathsfor different components of graphics data.
 20. The one or morenon-transitory computer-readable storage mediums of claim 19, whereinfiltering the processed data includes: filtering with an albedofiltering path; filtering with a specular filtering path; and filteringwith a diffuse filtering path.